Os memory addressing
1 / 38

OS Memory Addressing - PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

OS Memory Addressing. Architecture. CPU Processing units Caches Interrupt controllers MMU Memory Interconnect North bridge South bridge PCI, etc. PC Architecture. Address Spaces. Translation from logical to physical addresses. 2 N. Address space 1. 2 N. Process 1. 0.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

Download Presentation

OS Memory Addressing

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

OS Memory Addressing


  • CPU

    • Processing units

    • Caches

    • Interrupt controllers

    • MMU

  • Memory

  • Interconnect

  • North bridge

  • South bridge

  • PCI, etc

PC Architecture

Address Spaces

  • Translation from logical to physical addresses


Address space 1


Process 1


Process 3


Address space 3

Process 2




Address space 2



Physical Address space

Virtual/Logical Address spaces

Hardware Support

  • Two operating modes

    • Privileged (protected, kernel) mode: OS context

      • Result of OS invocation (system call, interrupt, exception)

      • Allows execution of privileged instructions

      • Allows access to all of memory (sort of)

    • User Mode: Process context

      • Only access resources (memory) in its context (address space)

  • Segmentation (Logical addressing)

    • Base register: Start location for address space

    • Limit register: Size of segment making up address space


  • Translation on every memory access in user process

    • Compare logical address to limit register

      • If logical address is greater, ERROR

    • Physical Address = base register + logical address

Managing Processes w/ Base and Limits

  • Context Switch

    • Add base and limit registers to process context

    • Context Switch steps

      • Change to privileged mode

      • Save base and limit registers of old process

      • Load base and limit registers of new process

      • Change to user mode and jump to new process

  • Protection Requirement

    • User process can not change base and limit

    • User process can not run in privileged mode

  • What if base and limit registers don’t change during context switch?

Pros and Cons of Segmentation

  • Advantages

    • Supports dynamic relocation of address spaces

    • Supports protection across multiple address spaces

    • Cheap: Few registers and little logic

    • Fast: Add and Compare is easy

  • Disadvantages

    • Each process must be allocated contiguously in real memory

      • Fragmentation: Cannot allocate a new process

    • Must allocate memory that may not be used

    • No Sharing: Cannot share limited memory regions

Using Segments

  • Divide address space into logical segments

    • Each logical segment can be in separate part of physical memory

    • Separate base and limit for each segment (+ protection bits)

      • Read and write bits for each segment

  • How to designate segment?

    • Use part of logical address

      • Top bits of logical address select segment

      • Low bits of logical address select offset within segment

    • Implicitly by type of memory reference

      • Code vs. Data segments

    • Special registers

Segment Table

  • Segment Table: Base and limit for every segment in process

    • Translation: Indirection -> Table lookup before Add and Compare


Seg 2


Where is:






Seg 1




Assume segments are selected via the logical address.


Seg 0




Pros and Cons of Segmentation

  • Advantages

    • Different protection for different segments

      • E.g Code segment is read only

    • Enables sharing of selected segments

    • Easier to relocate segments than entire address space

    • Enables sparse allocation of address space

  • Disadvantages

    • Still expensive/difficult to allocate contiguous memory to segments

    • Fragmentation: Wasted memory

  • Next approach: Paging

    • Allocation is easier

    • Reduces fragmentation


  • Rep movs

    • See Architecture Manual

x86 Segments

  • CS = Code Segment

  • DS = Data Segment

  • SS = Stack Segment

  • ES, FS, GS = Auxiliary segments

    • Explicit or implicitly specified by instructions

  • Accessed via special registers

    • 16 bit “Selectors”

    • Identify the segment to the hardware MMU

  • Functionality depends on CPU operating mode

Memory Map

  • Early PC’s depended on BIOS for hardware interactions

    • Standard library

    • Implemented as Real Mode code

      • (16 bit instructions)

    • Hardwired directly into memory

  • All x86 CPUs start execution at 0xffff0

    • Where is that?

  • 1MB of available memory

    • On a 16 bit architecture?

Real Mode (16 bits)

  • Segment registers act as base address

    • 16 bits

    • Segment size = 64K (216)

  • Translation:

    • Physical Addr = (segaddr << 4) + logical addr

  • x86 init values:

    • CS: 0xf000

    • IP: 0xfff0

  • Goal when in Real Mode:

    • Get Out of Real Mode

    • First thing OS does is transition to Protected (32 bit) mode

32 bit Memory Map

  • 32 bit addresses

    • Up to 4GB (232)

    • Top of memory used by hardware again

      • “Who would ever need more than 3GB of memory?”

  • BIOS is still there

    • Why?

    • Is it still useful?

Protected Mode (32 bits)

  • Segment information now stored as a table

    • GDT (Global Descriptor Table)

      • Where is the GDT?

    • Array of segment descriptions (base, limit, flags)

  • Segment registers now indicate array index

    • Segment registers select segment descriptor

      • CS points to Code Segment descriptor in GDT

    • Still 16 bits

  • How does Linux use segments?

  • Check architecture manuals

Linear address calculation

Segment descriptors

Segmentation Registers


  • Memory divided into fixed-sized pages

    • Typical page size: 512-16k bytes

Address space 1

Address space 2

Free Page

Address space 3

Free Page

Free Page

Virtual Memory

Physical Memory

Page Translation

  • How are virtual addresses translated to physical addresses

    • Upper bits of address designate page number

12 Bits

20 Bits

4K Pages

Page Number

Page Offset



Page Table

Page Base Address

Page Offset



  • No comparison or addition: Table lookup and bit substitution

  • 1 page table per process: One entry per page in address space

    • Base address of each page in physical memory

    • Read/Write protection bits

  • How many entries in page table?

Page Table Example

  • Mapping of virtual addresses to physical memory

Address space 1



4KB Pages



Page Table for process 1

Free Page

Free Page

Free Page

Physical Memory

Advantages of Paging

  • Fast to allocate and free

    • Alloc: Keep free list of pages and grab first page in list

      • No searching by first-fit, best-fit

    • Free: Add page to free list

      • No inserting by address or size

  • Easy to swap-out memory to disk

    • Page size matches disk block size

    • Can swap-out only necessary pages

    • Easy to swap-in pages back from disk

Disadvantages of Paging

  • Additional memory reference -> Inefficient

    • Page table too large to store as registers in MMU

      • Page tables kept in main memory

      • MMU stores only base address of page table

  • Storage for page tables may be substantial

    • Simple page table -> Require entry for all pages in address space

      • Even if actual pages are not allocated

    • Solution: Hierarchical page tables

      • Increase granularity of page table entries

  • Internal fragmentation: Page size does not match allocation size

    • How much memory is wasted (on average) per process?

    • Wasted memory grows with larger pages

Paging with Large Address Spaces

  • Mapping of logical addresses to physical memory

  • Page table for process

Free Page

Free Page

Physical Memory

How are entries skipped?

Combine paging and segmentation

  • Structure

    • Segments correspond to logical units: code, data, stack

      • Segments very in size and are often large

    • Each segment contains one or more (fixed-size) pages

      • But no longer needs to be contiguous

  • Multiple ways to combine them:

    • System 370: Each segment got own page tables

Seg #

(4 bits)

Page #

(8 bits)

Page offset

(12 bits)

Why 12 Bits?

  • x86: First calculate segment offset then do page table lookup

    • logical address -> linear address -> physical address

Segments + Pages Advantages

  • Advantages of Segments

    • Supports large memory regions

      • Single entry can cover all memory

      • Translation is fast and cheap

  • Advantages of Paging

    • Memory does not have to exist (on demand)

    • Can remap memory without copying

  • Advantages of both

    • Can use protection of segments without preallocating memory

    • Other advantages?

Protected Mode + Paging

  • Segmentation -> Paging -> Physical address

    • Every address in a page table points to a physical address

      • Virtual addresses are only an INDEX into page tables

  • Page size: 4KB

    • Data and page table pages

      • Page table page?

    • 1024 entries per page table page

  • 2 Level Page Tables

    • Page tables set via CR3 (What is this?)

    • Top Level: Entire 4GB of virtual address space

    • 2nd level: 4MB of virtual address space

  • Large Pages

    • Contiguous mappings of virtual addresses to physical addresses

Page Table formats

Paging Translation

Long Mode (64 bits)

  • Segments no longer used

    • Present but must be set to a flat model

  • Addresses now 64 bits

    • But pages are still 4KB

  • Page table hierarchy now has 4 levels

    • Check architecture manuals

  • Page table pages now only include 512 entries

    • Last level page table only covers 2MB of addresses

Early Memory (un)managementA history of the x86

  • Simple layout with a single segment per process

    • Early batch monitors

    • Personal computers

  • Disadvantages

    • Only one process can run at a time

    • Process can destroy OS



OS resides in

High memory



Process has memory

0 to OS break


Goals for Multiprogramming

  • Sharing

    • Several processes coexist in main memory

  • Transparency

    • Processes not aware memory is shared

    • Run regardless of number and/or locations of processes

  • Protection

    • Cannot corrupt OS or other processes

    • Privacy: Cannot read data of other processes

  • Efficiency should not be severely degraded

    • Purpose of sharing is to increase efficiency

    • CPU and memory resources not wasted

Static Relocation

  • Transparency == Relocation

    • Processes can run anywhere in memory

      • Can’t predict in advance

    • Modify addresses statically (ala linking)

      • when process is loaded

  • Advantages

    • Allow multiple processes to run

    • Requires no hardware support



Process 3

Process 2

Process 1


Disadvantages of Static Relocation

  • Process allocation must be contiguous

    • Fragmentation: May not be able to allocate new process

      • What Kind?

    • Processes may not be able to increase address space

    • Can’t move process after it has been placed

  • No Protection:

    • Destroy other processes and/or OS



Process 3

Process 2

Process 1


Dynamic Relocation

  • Translate address dynamically at every reference








  • Program-generated address translated to hardware address

    • Program addresses: Logical or virtual addresses

    • Hardware addresses: Physical or real addresses

  • Address space: View of memory for each process

Managing Processes with Segments

  • Process Creation

    • Find contiguous space for each segment

    • Fill in each base and limit value in segment table

  • Additional memory allocation when no contiguous space

    • Compact memory (move all segments, update bases)

    • Swap one or more segments to disk

  • Context Switch

    • Include segment table in process context

  • Process Exit

    • Free segments

  • Login