Os9 2

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

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

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

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 ?

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 .

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 .

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 OpenFileMapping(), UnmapViewofFile (), CloseHandle() Shmdt () Shmctl () OpenFileMapping (), MapViewofFile () Shmat () CreateFileMapping () shmget () Win32 Unix

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sharing without Virtual Memory 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. Physical Memory System Components User Programs All memory of a process is contiguous physically. User Program 1 User Program 2

Sharing without Virtual Memory 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. Physical Memory System Components User Programs All memory of a process is contiguous physically.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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 : The total set of shared modules is known a priori . Resolved by an effective loader  done just-in-time and only once .

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

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 .

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.

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

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.

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

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

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

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

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

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

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

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)

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

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.

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

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

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

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

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

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

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

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

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

Distributed Share Memory (DSM) 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 Memory Memory Memory Distributed System The illusion of a single shared memory

Distributed Share Memory (DSM) 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 Memory Memory Memory Distributed System 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.

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

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

Structured 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: P1 P2 P n Local address space shared shared shared MM1 MM2 MM n DSM

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

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

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.

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 .

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.

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)

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

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

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

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

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

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

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

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

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

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)

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

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

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.

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.

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

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

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

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

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.

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.

Os9 2

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Os9 2 (20)

More from issbp (19)

Os9 2