3. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Single-Copy Sharing
4.
5.
6.
7.
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
29.
30. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Static Linking and Sharing
31.
32.
33.
34.
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 : . . . . . . . . .
47.
48.
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 ).
53.
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
61.
62. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Dynamic Linking and Sharing
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
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
72.
73.
74.
75.
76.
77.
78. Operating Systems Principles Memory Management Lecture 9: Sharing of Code and Data in Main Memory Implementations of DSM
79.
80.
81.
82.
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)