1. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory 主講人：虞台文

2. Content Single-Copy Sharing – Reasons of Sharing – Requirements for Sharing Static Linking and Sharing – Sharing in Systems w/o Segmentation or Paging – Sharing in Paging Systems – Sharing in Segmented Systems Dynamic Linking and Sharing Principles of Distributed Shared Memory (DSM) – The User's View of DSM Implementations of DSM – Implementing Unstructured DSM – Implementing Structured DSM

3. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Single-Copy Sharing

4. Sharing Reusing Software Modules – Individual software modules are constructed separately. – Develop applications by linking with other well-developed software modules. – Reduce software developing cost. – Each process owns private copy of shared objects Single-Copy Sharing – Processes share a single copy of code or data in memory – Why? – What? – How?

5. Why? Processes need to access common data, e.g., – Communication btw producer & consumer – Cooperation among divide-and-conquer processes – Competition on resources Better utilization of memory (code & data) – Several active processes use the same code or data at the same time, e.g., many users running the same editor or debugger in a time-sharing system – Without sharing, memory requirement would increase dramatically and, thus, reduce the number of login users. increase I/O overhead to load excess copies increase the page fault rate and, thus, the risk of thrashing.

6. What? OS kernel routines – I/O drivers – System services, e.g., memory management and file manipulation routines. – System utilities, e.g., Compiler, linker, loader and debugger. User-lever applications – A single copy of the same code applies to different data sets.

7. How? How to express what is shared? – System Components Designated at the time of system design or initialization – User-Level Applications Shared code must be reentrant (read-only, “pure”) – Stack and heap must be replicated per process UnixWin32 shmgetshmget()CreateFileMappingCreateFileMapping() ShmatShmat()OpenFileMappingOpenFileMapping(), MapViewofFile()MapViewofFile ShmdtShmdt()OpenFileMapping(), UnmapViewofFile(), CloseHandle()UnmapViewofFile ShmctlShmctl()

8. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } Compile

9. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax...

10. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax......... esp

11. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 5...... esp

12. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 5 7...... esp

13. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 5 7...... esp 7

14. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 5 7...... esp 75

15. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 5 7 Return Address...... esp 75 Return Address

16. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... esp 5 7 75 Return Address

17. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... esp 5 7 75 Return Address old ebp

18. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... esp 5 7 75 Return Address old ebp ebp+8 ebp+12 i j

19. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address old ebp ebp+8 ebp+12 i j eax=5

20. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address old ebp ebp+8 ebp+12 i j eax=12

21. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address old ebp ebp+8 ebp+12 i j eax=24

22. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address old ebp ebp+8 ebp+12 i j eax=24 esp

23. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address old ebp eax=24 esp

24. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret _AddMul2: push ebp mov ebp,esp mov eax, [bp+8] add eax, [bp+8+4] shl eax, 1 mov esp,ebp pop ebp ret...... 5 7 75 Return Address eax=24 esp _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... Return Address

25. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ }...... 5 7 75 eax=24 esp _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax...

26. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ } int x, y, z; int AddMul2(int i, int j) { return (i+j)*2; } main() { x=5; y=7; z=AddMul2(x, y);........ }...... 5 7 eax=24 esp _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax... 24

27. Example: Simple Code Sharing _STACKSEGMENT PUBLIC ‘STACK’ DB4096 dup(?) Bottom: _STACKENDS _DATASEGMENT PULBIC ‘DATA’ xdd 1 dup(?) ydd 1 dup(?) zdd 1 dup(?) _DATAENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2:... // code for AddMul2 _main:... // code for main _TEXTENDS Pure code is sharable Each process has its own stack segment Each process has its own data segment

28. Example: Simple Code Sharing Translate to the same physical process for different processes Access different data areas for different processes

29. Linking and Sharing Sharing are closely related to linking – Linking resolves external references – Sharing links to the same module Static linking/sharing: – Resolve references before execution starts Dynamic linking/sharing: – Resolve references while executing

30. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Static Linking and Sharing

31. Sharing without Virtual Memory Physical Memory Physical Memory System Components User Programs With one or no Relocation Register (RR) – Sharing user programs: Possible only by partial overlapping Too restrictive and difficult; generally not used – Sharing system components: Agree on a starting positions Linker resolves references to those locations Can also use a block of “transfer addresses,” but this involves additional memory references. Issues  difficult to identify the invoking processes by system components. All memory of a process is contiguous physically. User Program 1 User Program 2

32. Sharing without Virtual Memory Physical Memory Physical Memory System Components User Programs With one or no Relocation Register (RR) – Sharing user programs: Possible only by partial overlapping Too restrictive and difficult; generally not used – Sharing system components: Agree on a starting positions Linker resolves references to those locations Can also use a block of “transfer addresses,” but this involves additional memory references. Issues  difficult to identify the invoking processes by system components. All memory of a process is contiguous physically.

33. Sharing without Virtual Memory With multiple RR’s CBR = Code Base Reg. Point to shared copy of code SBR = Stack Base Reg. Point to private copy of stack DBR = Data Base Reg. Point to private copy of data Sharing of code

34. Sharing without Virtual Memory With multiple RR’s CBR = Code Base Reg. Point to private copy of code SBR = Stack Base Reg. Point to private copy of stack DBR = Data Base Reg. Point to shared copy of data Sharing of data code 1 code 2      stack 1 stack 2      data                CBR 1 SBR 1 DBR 1      CBR 2 SBR 2 DBR 2 process 1 process 2

35. Sharing in Paging Systems  Sharing of Data Data Database Common data (without address)

36. Sharing in Paging Systems  Sharing of Data Data Data 1 Data 2 Data 3 Data 2 Data 3 Data 1 Database Physical Memory

37. Sharing in Paging Systems  Sharing of Data Data 2 Data 3 Data 1 Physical Memory............ PT 1 0 n1n1............ PT 2 0 n2n2 n 2, w Database n 1, w

38. Sharing in Paging Systems  Sharing of Data Data 2 Data 3 Data 1 Physical Memory............ PT 1 0 n1n1............ PT 2 0 n2n2 n 2, w Database n 1, w The page numbers of sharing processes can be different.

39. bra label1 label1: bra label1 label1:.................. Sharing in Paging Systems  Sharing of Code 0x0000 0x2000 0x1000 4k4k 4k4k 4k4k w bra (2,w) label1: bra (2,w) label1:.................. 0x0000 0x2000 0x1000 Assemble

40. Sharing in Paging Systems  Sharing of Code bra (2,w) label1: bra (2,w) label1:.................. 0x0000 0x2000 0x1000 bra (n+2,w) label1:.................. Virtual Memory n th page Shared code

41. Sharing in Paging Systems  Sharing of Code bra (n+2,w) label1:.................. Virtual Memory n th page bra (n+2,w)............ Label1:...... Physical Memory p q r

42. Sharing in Paging Systems  Sharing of Code bra (n+2,w) label1:.................. Virtual Memory n th page bra (n+2,w)............ Label1:...... Physical Memory r r q q p p n n+1 n+2 PT p q r

43. Sharing in Paging Systems  Sharing of Code bra (n+2,w)............ Label1:...... Physical Memory n 2, w n 1, w r r q q p p n1 n1+1 n1+2 PT 1 0 0 r r q q p p n2 n2+1 n2+2 PT 2 0 0 r r q q p p n n+1 n+2 PT p q r

44. Sharing in Paging Systems  Sharing of Code bra (n+2,w)............ Label1:...... Physical Memory n 2, w n 1, w r r q q p p n1 n1+1 n1+2 PT 1 0 0 r r q q p p n2 n2+1 n2+2 PT 2 0 0 r r q q p p n n+1 n+2 PT p q r If absolute virtual address is used for coding, such a code sharing scheme is workable if n 1 = n 2 = n If absolute virtual address is used for coding, such a code sharing scheme is workable if n 1 = n 2 = n

45. Sharing in Paging Systems  Sharing of Code bra (n+2,w)............ Label1:...... Physical Memory n 2, w n 1, w r r q q p p n1 n1+1 n1+2 PT 1 0 0 r r q q p p n2 n2+1 n2+2 PT 2 0 0 r r q q p p n n+1 n+2 PT p q r Can we assign different starting page numbers to a different processes?

46. Sharing in Paging Systems  Sharing of Code bra (n+2,w) label1:.................. Virtual Memory n th page 1. Shared code is self-contained Can we assign different starting page numbers to a different processes? 2. Avoid using absolute address (page number) in share code, i.e., using address relative to CBR instead. Yes, if …

47. Sharing in Paging Systems  Short Summary PT entries of different processes point to the same page frame Data pages: No Restrictions Code pages: – Must have the same page numbers in all PTs. – For generalization, avoid using page numbers in shared code (self-contained), i.e., using address relative to CBR instead.

48. Sharing in Paging Systems  Short Summary PT entries of different processes point to the same page frame Data pages: No Restrictions Code pages: – Must have the same page numbers in all PTs. How to know the page numbers of shared components? Solutions: 1. The total set of shared modules is known a priori. 2. Resolved by an effective loader  done just-in-time and only once.

49. Dynamic Linking via Transfer Vector... bri tv[i]... bri tv[i]... Transfer Vectors Currently Executing Code Linking just-in-time and only once. call the same shared function by indirect branch instruction.... stub 0 1 i n1n1

50. Dynamic Linking via Transfer Vector... bri tv[i]... bri tv[i]... Transfer Vectors Currently Executing Code Linking just-in-time and only once.... stub 0 1 i n1n1 When the shared function is called first time, the external reference is resolved by the corresponding stub.

51. Dynamic Linking via Transfer Vector... bri tv[i]... bri tv[i]... Transfer Vectors Currently Executing Code Linking just-in-time and only once.... stub 0 1 i n1n1 When the shared function is called first time, the external reference is resolved by the corresponding stub. Shared code When the external reference is resolved, the stub replaces the corresponding transfer vector to point to the shared code.

52. Dynamic Linking via Transfer Vector... bri tv[i]... bri tv[i]... Transfer Vectors Currently Executing Code Linking just-in-time and only once.... stub 0 1 i n1n1 Shared code Once the external reference is resolved, it can be used directly later on. Used by Win32 and POSIX (DLLs).

53. Sharing in Segmented Systems Much the same as with paged systems – Using segments instead of pages Actually, simpler and more elegant because segments represent logical program entities.

54. Sharing in Segmented Systems  Sharing of Data Database Physical Memory Shared Data............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, w s 1, w ST entries of different processes point to the same segment in PM.

55. Sharing in Segmented Systems  Sharing of Data Database Physical Memory Shared Data............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, w s 1, w ST entries of different processes point to the same segment in PM. How about if a segment is also paged?

56. Physical Memory Sharing in Segmented Systems  Sharing of Data............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, p, w s 1, p, w ST entries of different processes point to the same page table in PM. Data 2 Data 3 Data 1 p PT Paging How about if a segment is also paged?

57. ? Sharing in Segmented Systems  Sharing of Code Physical Memory Shared Code............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, w s 1, w ST entries of different processes point to the same segment in PM. In what condition the scheme is workable? The code must be self-contained.

58. ? Sharing in Segmented Systems  Sharing of Code Physical Memory Shared Code............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, w s 1, w ST entries of different processes point to the same segment in PM. How about if a segment is also paged? In what condition the scheme is workable? The code must be self-contained.

59. ? In what condition the scheme is workable? Physical Memory Sharing in Segmented Systems  Sharing of Code............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, p, w s 1, p, w ST entries of different processes point to the same page table in PM. Code 2 Code 3 Code 1 p PT Paging How about if a segment is also paged? The code must be self-contained.

60. ? In what condition the scheme is workable? Physical Memory Sharing in Segmented Systems  Sharing of Code............ ST 1 0 s1s1............ ST 2 0 s2s2 s 2, p, w s 1, p, w ST entries of different processes point to the same page table in PM. Code 2 Code 3 Code 1 p PT How about if the shared code is not self-contained? The code must be self-contained. Assign the same segment numbers for all share codes in STs.

61. Sharing in Segmented Systems  Summary Much the same as with Paged Systems Actually, simpler and more elegant because Segments represent logical program entities ST entries of different processes point to the same segment in physical memory (PM) Data pages: No restrictions Code pages: – Assign same segment numbers in all STs, or – Use base registers: Function call loads CBR Self-references have the form w(CBR) Other references have the form (s,w)

62. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Dynamic Linking and Sharing

63. Unrestricted Dynamic Linking/Sharing Segmentation facilitates to implement a fully general scheme of dynamic linking and sharing. – Any two processes (user or system) can share any portion of their space. Pioneered in the MULTICS operating system.MULTICS

64. Unrestricted Dynamic Linking/Sharing i j Segment table Code segment C load*ld (S, W) Linkage section for C CBR trap on Symbol table d LBR

65. Unrestricted Dynamic Linking/Sharing i j Segment table Code segment C load*ld (S, W) Linkage section for C CBR trap on Symbol table d Addressing relative to linkage section Displacemen t Indirect addressing The address for external reference Not ready now LBR

66. Unrestricted Dynamic Linking/Sharing i j Segment table Code segment C load*ld (S, W) Linkage section for C CBR trap on Symbol table d Generated by the compiler LBR

67. Unrestricted Dynamic Linking/Sharing i j Segment table Code segment C load*ld (S, W) Linkage section for C CBR trap on Symbol table d Resolve the external reference dynamically by the exception handler when the corresponding instruction is executed. LBR

68. Unrestricted Dynamic Linking/Sharing i j Segment table Code segment C load*ld (S, W) Linkage section for C CBR trap on Symbol table d Resolve the external reference dynamically by the exception handler when the corresponding instruction is executed. LBR Segment S w trap off(s, w) s

69. Unrestricted Dynamic Linking/Sharing Before external reference is executed After external reference is executed

70. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Principles of Distributed Shared Memory (DSM)

71. Memory Sharing on Different Computer Architecture Memory Single processor/ Single memory module Multiple processor/ Single memory module Distributed System

72. Distributed Share Memory (DSM) Memory Distributed System VM – Creates the illusion of a memory that is larger than the available physical memory DSM – Creates the illusion of a single shared memory The illusion of a single shared memory

73. Distributed Share Memory (DSM) Memory Distributed System Goal of DSM – To alleviate the burden of programmer by hiding the fact that physical memory is distributed DSM – Creates the illusion of a single shared memory The illusion of a single shared memory

74. Distributed Share Memory (DSM) Memory Distributed System Goal of DSM – To alleviate the burden of programmer by hiding the fact that physical memory is distributed DSM – Creates the illusion of a single shared memory The illusion of a single shared memory Great overhead on message- passing to resolve remote memory access. To make DSM viable, efficiency on data transfer is an important consideration. Great overhead on message- passing to resolve remote memory access. To make DSM viable, efficiency on data transfer is an important consideration.

75. How to implement transfers efficiently? Two approaches: Optimize the implementation – Exploiting locality of reference or using data replication – Most important with Unstructured DSM Restrict the full generality of the DSM – Exploiting what the user knows – Basic to Structured DSM

76. Unstructured DSM P1 P2 PnPn PnPn MM1 MM2 MMn 0 p1p1 0 p1p1 0 p1p1 DSM 0 np  1 Simulate single, fully shared, unstructured memory. Advantage: Fully “transparent” to user Disadvantage: Efficiency

77. Structured DSM P1 P2 PnPn PnPn MM1 MM2 MMn Local address space shared DSM Share only portion of memory, e.g., a collection of functions and shared variables, determined by user. For efficiency, add restrictions on use of shared variables: – Access only within (explicitly declared) Critical Sections Variant: “object-based DSM” – Use “objects” instead of shared variables:

78. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Implementations of DSM

79. Implementing Unstructured DSM – Granularity of data transfers – Replication of data – Memory consistency – Tracking data Implementing Structured DSM – Critical-section based – Object based

80. Implementing Unstructured DSM  Granularity of Data Transfers Transfer too little: – Time wasted in latency (startup cost) Transfer too much: – Time wasted in transfer – False sharing A nature choice is to use the page size (or its multiple) as the granularity for transfer.

81. Implementing Unstructured DSM  Replication of Data What action should be taken when a page fault? Two possible choices: – Move the page from the remote to the requesting processor Problems: Heavy network traffic, trashing, and delay – Make a copy of the page from the remote to the requesting processor Advantages: decrease network traffic, less trashing, and reduce delay Issue: How to maintain memory consistency? Read work fine  no action needed Writes require others to update or invalidate.

82. Implementing Unstructured DSM  Replication of Data Rules to maintain memory consistency Allowing only one copy of writable page, but multiple copies of read-only pages.

83. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2

84. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B read

85. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B read Operation is done locally. No extra action need to be taken. Operation is done locally. No extra action need to be taken.

86. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write

87. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write Operation is done locally. No extra action need to be taken. Operation is done locally. No extra action need to be taken.

88. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write

89. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write Invalidate copy in MM2; Upgrade copy in MM1 to writable. Invalidate copy in MM2; Upgrade copy in MM1 to writable. page B (writable) page B (writable)

90. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) page B (read-only) DSM page A (writable) page B (read-only) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B read page B (writable) page B (writable)

91. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 page A (writable) DSM page A (writable) P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B read page B (writable) page B (writable) Downgrade page in MM1 to read- only; Make copy in MM2. Downgrade page in MM1 to read- only; Make copy in MM2. page A (read-only) page A (read-only) page A (read-only)

92. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 DSM P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write page B (writable) page B (writable) page A (read-only) page A (read-only) page A (read-only)

93. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 DSM P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B write page B (writable) page B (writable) page A (read-only) page A (read-only) page A (read-only) page B (writable) Transfer page from MM1 to MM2.

94. Implementing Unstructured DSM  Replication of Data Allowing only one copy of writable page, but multiple copies of read-only pages. Example: MM1 MM2 DSM P1 P2 P1 reads A P1 writes A P1 writes B P2 reads A P2 writes B page B (writable) page A (read-only) page A (read-only) page A (read-only) page B (writable)

95. Implementing Unstructured DSM  Memory Consistency a1=1, b1=2 a2=1, b2=2 a1=1, b1=2 a2=0, b2=0 a1=1, b1=2 a2=0, b2=1 a1=1, b1=2 a2=1, b2=2

96. Implementing Unstructured DSM  Memory Consistency a1=1, b1=2 a2=1, b2=2 a1=1, b1=2 a2=0, b2=0 a1=1, b1=2 a2=0, b2=1 a1=1, b1=2 a2=1, b2=2 Strict Consistency Sequential Consistency

97. Implementing Unstructured DSM  Memory Consistency Strict Consistency: – Reading a variable x returns the value written to x by the most recently executed write operation. Sequential Consistency: – Sequence of values of x read by different processes corresponds to some sequential interleaved execution of those processes.

98. Implementing Unstructured DSM  Tracking Data Tracking Data: Where is it stored now? Approaches: – Have “owner” track it by maintaining “copy set”. Only owner is allowed to write. Ownership can change. To find the owner using broadcast. – Central Manager → Bottleneck Multiple “replicated” managers split the responsibilities. – “Probable owner” gets tracked down  e.g., via page table. Retrace data’s migration. Update links traversed to show current owner.

99. Implementing Unstructured DSM  Discussion All variables in the shared space are assumed consistent all the time. – Moving and/or invalidating pages may be needed on write Much network traffic can be generated, resulting in poor performance. Solution: – Structured DSM  requires a new model of memory consistency

100. Implementing Structured DSM  Consistencies Weak Consistency (Dubois et al. 1988) – Consistency by requesting synchronization explicitly. Release Consistency (Gharachorloo 1990) – Consistency upon leaving a CS Entry Consistency (Bershad 1993) – Consistency upon entering a CS

101. Implementing Structured DSM  Weak Consistency Introduce “synchronization variable,” S Processes access it when they are ready to adjust/reconcile their shared variables.

102. Implementing Structured DSM  Release Consistency Synchronize upon leaving CS – A waste if p 2 never looks at x.

103. Implementing Structured DSM  Entry Consistency Before entering CS, import only those variables used There is also a “lazy release consistency” (Keleher et al. 1992) which imports all shared variables before entering CS.

104. Object-Based DSM An object encapsulates data and methods. Can use remote method invocation (like remote procedure calls, covered earlier) instead of copying or moving an object into local memory. One can move an object to improve performance.