Please enable JavaScript.

Coggle requires JavaScript to display documents.

Virtual memory (Page replacement (Over-allocating (A process is given less…

- - - - find a frame that is ot used
      - Move it to memory
      - Mark it as invalid on the table
    - - Modify bit
        
        Each page has one bit
        
        whenever the byte is written
        
        Indicates page has been modified
        
        If not on, no need to write on disk
  - - - The time it was brought in to memory
        
        When space is needed
        
        The oldest one goes out
  - - - No Belady's anomaly
  - - - To create space
      - Doesn's suffer from Belady
  - - - Additional reference bits algorithm
        
        Reference bits are recorded on intervals
        
        Contains a history of usage
        
        The one with the smallest goes out
      - Second chance algorithm
        
        If a page gets a second chance
        
        The refrence bit is cleared
        
        Arrival time is reset to current
        
        circular queue
      - Enhanced second chance
        
        Considers the reference
        and modify bits
  - - - Database systems
- - - - Less page fault
  - - - Proportional to size
  - - - Allows process to select
        replacement frame from all frames
    - - Local requires each process select
        only from it;s own set
- - - - Loaded into memory
      - Lazy swapper
        
        Never swaps a page unless it will be needed
        
        Known as pager
        
        Handles page per page
  - - - Memory resident
        
        Program executes normally
      - Absent
        
        Page fault
        
        Operating system trap
        
        exception handling
        
        Internal table is checked
        
        If the reference was invalid, process terminated
        
        A frame is found
        
        A disk operation is scheduled to allocate paage
        
        When the read is complete, internal table is modified
        
        The instruction is restarted.
    - - Never bring a page until it;s required
    - - calls usually are close in memory
  - - - How much time is
        needed to access memory
      - in demand page systems
        
        p = probability of fault
        
        time = (1-p)200 + P8000000
        
        if page-fault rate = 1/1000
        
        40 times slowdown
- - - - A disk block is mapped to pages in memory
      - initial access proceeds on demdand paging
  - - - Creates a shared-memory object
- - - - Performance problems
      - Can be limited using
        
        Local replacement algorithm
        
        If a process thrashes
        
        Cant stealframes from another process
      - To prevent
        
        A process must be provided with
        
        as many frames as it needs
        
        Locality model
        
        Pages that are used together
    - - Based on assumption of locality
        
        Sets a working set
- - - - The kernel requests memory for
        varying sizes,
        
        some are smaller than a page
        
        Reduce fragmentation
      - Pages allocated to user mode
        
        Do not need to be contiguous
        
        Hardware might require congiuous
    - - Allocates from a fixed-size segment
        
        power-of-2 allocator
        
        4kb,8kb,...
        
        Divided in buddies
        
        Until appropiate size is met
  - - - made up of one or more contigupus pages
    - - One or more slabs
    - - populates the cache
    - - When created
        
        objects are allocated
        
        Three states
        
        Full
        
        Empty
        
        Partial
        
        Two main benefits
        
        No memory waste on fragmentation
        
        Memory requests can be satisfied quckly
- - - - Not needed at the same time
      - over-allocation of memory
    - - Separation of logical and physical memory
      - Virtual address spaces
        
        logical view how a process is stored in memory
        
        If there are holes
        
        Sparse
      - Growth
        
        Stack grows downward
        
        Heap grows upward
      - Shared memory
        
        Logical views allow
        
        Programs to share a physical space
- - - - a new copy is made
        
        Location from which the
        free page will be located
        
        OSs provide a pool of free pages
        for requests
        
        Zero-fill-on-demand
        
        Pages are zeroed out
        
        and then allocated