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

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

8. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . .

10. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . . . . esp

11. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . 5 . . . esp

12. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . 5 7 . . . esp

13. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . 5 7 . . . esp 7

14. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . 5 7 . . . esp 7 5

15. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . . . . 5 7 . . . Return Address esp 7 5 Return Address

16. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 esp 7 5 Return Address

17. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 esp 7 5 Return Address old ebp

18. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 i j esp 7 5 Return Address old ebp ebp ebp+8 ebp+12

19. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 i j eax= 5 7 5 Return Address old ebp ebp ebp+8 ebp+12

20. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 i j eax= 12 7 5 Return Address old ebp ebp ebp+8 ebp+12

21. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 i j eax= 24 7 5 Return Address old ebp ebp ebp+8 ebp+12

22. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 i j eax= 24 7 5 Return Address old ebp ebp ebp+8 ebp+12 esp

23. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 eax= 24 7 5 Return Address old ebp esp

24. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 . . . 5 7 eax= 24 _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax . . . . . . 7 5 Return Address esp Return Address

25. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 _main: mov ds:[x],5 mov ds:[y],7 push ds:[y] push ds:[x] call _AddMul2 add esp,8 mov ds:[z],eax . . . . . . 7 5 esp

26. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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 _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 esp

27. Example: Simple Code Sharing _STACK SEGMENT PUBLIC ‘STACK’ DB 4096 dup(?) Bottom: _STACK ENDS _DATA SEGMENT PULBIC ‘DATA’ x dd 1 dup(?) y dd 1 dup(?) z dd 1 dup(?) _DATA ENDS _TEXT SEGMENT PUBLIC ‘CODE’ _AddMul2: . . . // code for AddMul2 _main: . . . // code for main _TEXT ENDS 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

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

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

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 n 2 , w n 1 , w Physical Memory . . . . . . PT 1 0 n 1 . . . . . . PT 2 0 n 2 Database

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

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

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

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

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

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

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

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

46. Sharing in Paging Systems  Sharing of Code 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 … bra (n+2,w) label1 : . . . . . . . . .

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 stub stub stub 0 1 i n  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 stub stub stub 0 1 i n  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 stub stub stub 0 1 i n  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 stub stub stub 0 1 i n  1 Shared code Once the external reference is resolved, it can be used directly later on . Used by Win32 and POSIX ( DLLs ).

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

55. Sharing in Segmented Systems  Sharing of Data Shared Data 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? Database Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2

56. Sharing in Segmented Systems  Sharing of Data 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 PT How about if a segment is also paged? Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2 p Paging

57. Sharing in Segmented Systems  Sharing of Code ? Shared Code 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. Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2

58. Sharing in Segmented Systems  Sharing of Code ? Shared Code 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. Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2

59. Sharing in Segmented Systems  Sharing of Code ? In what condition the scheme is workable ? 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 PT How about if a segment is also paged? The code must be self-contained. Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2 p Paging

60. Sharing in Segmented Systems  Sharing of Code ? In what condition the scheme is workable ? 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 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. Physical Memory . . . . . . ST 1 0 s 1 . . . . . . ST 2 0 s 2 p

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

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

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

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

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

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

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 Single processor/ Single memory module Multiple processor/ Single memory module Distributed System Memory Memory Memory Memory Memory

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

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

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 Operation is done locally . No extra action need to be taken. read

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 Operation is done locally . No extra action need to be taken. write

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 Invalidate copy in MM2; Upgrade copy in MM1 to writable. page B (writable) page B (writable) write

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 page B (writable) page B (writable) read

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 page B (writable) page B (writable) Downgrade page in MM1 to read-only; Make copy in MM2. page A (read-only) page A (read-only) page A (read-only) read

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 page B (writable) page B (writable) page A (read-only) page A (read-only) page A (read-only) write

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 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. write

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