CS 2510

1. CS 2510 OS Basics, cont’d

2. Dynamic Memory Allocation • How does system manage memory of a single process? • View: Each process has contiguous logical address space

3. Dynamic Storage Management • Static (compile-time) allocation is not possible for data • Recursive procedures • Even regular procedures are hard to predict (data dependencies) • Complex data structures • Storage used inefficiently when reserved statically • Must reserve enough to handle worst case • ptr = allocate(x bytes) • Free(ptr) • Dynamic allocation can be handled in 2 ways • Stack allocation • Restricted, but simple and efficient • Heap allocation • More general, but less efficient • Harder to implement

4. Stack Organization • Definition: Memory is freed in opposite order from allocation • Alloc(A) • Alloc(B) • Alloc(C) • Free(C) • Free(B) • Free(A) • When is it useful? • Memory allocation and freeing are partially predictable • Allocation is hierarchical • Example • Procedure call frames • Tree traversal, expression evaluation, parsing

5. Stack Implementation • Advance pointer dividing allocated and free space • Allocate: Increment pointer • Free: Decrement pointer • X86: Special ‘stack pointer’ register • ‘SP’ (16), ‘ESP’ (32), ‘RSP’(64) • Where does this register point to? • How does the x86 allocate and free? • Stack grows down • Advantage • Keeps all the free space contiguous • Simple and efficient to implement • Disadvantage: Not appropriate for all data structures

6. Heap Organization • Definition: Allocate from random locations • Memory consists of allocated areas and free areas (or holes) • When is it useful? • Allocation and release and unpredictable • Arbitrary list structures, complex data organizations • Examples: new in C++, malloc() in C • Advantage: Works on arbitrary allocation and free patterns • Disadvantage: End up with small chunks of free space Free 16 bytes How to allocate 24 bytes? Alloc 32 bytes 12 bytes Free Alloc 16 bytes

7. Fragmentation • Definition: Free memory that is too small to be usefully allocated • External: Visible to system • Internal: Visible to process (e.g. if allocation at some granularity • Goal • Keep number of holes small • Keep size of holes large • Stack allocation • All free space is contiguous in one large region • How do we implement heap allocations

8. Heap implementation • Data Structure: Linked list of free blocks • Free List tracks storage not in use • Allocation • Choose block large enough for request • According to policy criteria! • Update pointers and size variable • Free • Add block to free list • Merge adjacent free blocks • If (addr of new block == prev_addr + size) { • Combine blocks • } Project 2!!! Project 2!!! Project 2!!! Project 2!!! Project 2!!! Project 2!!!

9. x86 and Linux • Where is heap managed? • User space or kernel? • syscall_brk(); • Expands or contracts heap • A lot like a stack • Heap grows up • Dedicated virtual address area • Allocated space then managed by heap allocator • Backed by page tables

10. Best vs. First vs. Worst • Best fit • Search the whole list of each allocation • Choose bock that most closely matches size of request • Can stop searching if see exact match • First fit • Allocate first block that is large enough • Rotating first fit: Start with next free block each time • Worst fit • Allocate largest block to request (most leftover space) • Which is best?

11. Examples • Best algorithm: Depends on sequence of requests • Example: Memory contains 2 free blocks of size 20 and 15 bytes • Allocation requests: 10 then 20 • Allocation requests: 8, 12, then 12

12. Buddy Allocation • Fast simple allocation for blocks that are 2n bytes (Knuth 1968) • Allocation Restrictions • Block sizes 2n • Represent memory units (2min_order) with bitmap • Allocation strategy for k bytes • Raise allocation request to nearest 2n • Search free list for appropriate size • Recursively divide larger blocks until reach block of correct size • “Buddy” blocks remain free • Free strategy • Recursively coalesce block with buddy if buddy free • May coalesce lazily to avoid overhead

13. Example • 1MB of memory • Allocate: 70KB, 35KB, 80KB • Free: 70KB, 35KB

14. Comparison of Allocation Strategies • Best fit • Tends to leave some very large holes, some very small ones • Disadvantage: Very small holes can’t be used easily • First fit • Tends to leave “average” size holes • Advantage: Faster than best fit • Buddy • Organizes memory to minimize external fragmentation • Leaves large chunks of free space • Faster to find hole of appropriate size • Disadvantage: Internal fragmentation when not power of 2 request

15. Memory allocation in practice • Malloc() in C: • Calls sbrk() to request more contiguous memory • Add small header to each block of memory • Pointer to next free block or • Size of block • Where must header be placed? • Combination of two data structures • Separate free list for each popular size • Allocation is fast, no fragmentation • Inefficient if some are empty while others have lots of free blocks • First fit on list of irregular free blocks • Combine blocks and shuffle blocks between lists

16. Reclaiming Free Memory • When can dynamically allocated memory be freed? • Easy when a chunk is only used in one place • Explicitly call free() • Hard when information is shared • Can’t be recycled until all sharers are finished • Sharing is indicated by the presence of pointers to the data • Without a pointer, can’t access data (can’t find data) • Two possible problems • Dangling pointers: Recycle storage while its still being used • Memory leaks: Forget to free storage even when can’t be used again • Not a problem for short lived user processes • Issue for OS and long running applications

17. Reference Counts • Idea • Keep track of the number of references to each chunk of memory • When reference count reaches zero, free memory • Example • Files and hard links in Unix • Smalltalk • Objects in distributed systems • Linux Kernel • Disadvantages • Circular data structures -> memory leaks

18. Garbage Collection • Idea • Storage isn’t freed explicitly (i.e. no free() operation) • Storage freed implicitly when no longer referenced • Approach • When system needs storage, examine and collect free memory • Advantages • Works with circular data structures • Makes life easier on the application programmer

19. Mark and Sweep Garbage Collection • Requirements • Must be able to find all objects • Must be able to find all pointers to objects • Compiler must cooperate by marking type of data in memory. Why? • Two Passes • Pass 1: Mark • Start with all statically allocated (where?) and procedure local variables (where?) • Mark each object • Recursively mark all objects reachable via pointer • Pass 2: Sweep • Go through all objects, free those not marked

20. Garbage Collection in Practice • Disadvantages • Garbage collection is often expensive: 20% or more of CPU time • Difficult to implement • Languages with garbage collection • LISP (emacs) • Java/C# • Scripting languages • Conservative Garbage Collection • Idea: Treat all memory as pointers (what does this mean?) • Can be used for C and C++

21. I/O Devices • Two primary aspects of computer system • Processing (CPU + Memory) • Input/Output • Role of Operating System • Provide a consistent interface • Simplify access to hardware devices • Implement mechanisms for interacting with devices • Allocate and manage resources • Protection • Fairness • Obtain Efficient performance • Understand performance characteristics of device • Develop policies

22. I/O Subsystem User Process Kernel Kernel I/O Subsystem Harddisk Mouse GPU SCSI Bus Keyboard PCI Bus Device Drivers Software Hardware Harddisk Mouse GPU Device Controllers SCSI Bus Keyboard PCI Bus Harddisk Mouse GPU SCSI Bus Keyboard PCI Bus Devices

23. User View of I/O • User Processes cannot have direct access to devices • Manage resources fairly • Protects data from access-control violations • Protect system from crashing • OS exports higher level functions • User process performs system calls (e.g. read() and write()) • Blocking vs. Nonblocking I/O • Blocking: Suspends execution of process until I/O completes • Simple and easy to understand • Inefficient • Nonblocking: Returns from system calls immediately • Process is notified when I/O completes • Complex but better performance

24. User View: Types of devices • Character-stream • Transfer one byte (character) at a time • Interface: get() or put() • Implemented as restricted forms of read()/write() • Example: keyboard, mouse, modem, console • Block • Transfer blocks of bytes as a unit (defined by hardware) • Interface: read() and write() • Random access: seek() specifies which bytes to transfer next • Example: Disks and tapes

25. Kernel I/O Subsystem • I/O scheduled from pool of requests • Requests rearranged to optimize efficiency • Example: Disk requests are reordered to reduce head seeks • Buffering • Deal with different transfer rates • Adjustable transfer sizes • Fragmentation and reassembly • Copy Semantics • Can calling process reuse buffer immediately? • Caching: Avoid device accesses as much as possible • I/O is SLOW • Block devices can read ahead

26. Device Drivers • Encapsulate details of device • Wide variety of I/O devices (different manufacturers and features) • Kernel I/O subsystem not aware of hardware details • Load at boot time or on demand • IOCTLs: Special UNIX system call (I/O control) • Alternative to adding a new system call • Interface between user processes and device drivers • Device specific operation • Looks like a system call, but also takes a file descriptor argument • Why?

27. Device Driver: Device Configuration • Interactions directly with DeviceController • Special Instructions • Valid only in kernel mode • X86: In/Out instructions • No longer popular • Memory-mapped • Read and write operations in special memory regions • How are memory operations delivered to controller? • OS protects interfaces by not mapping memory into user processes • Some devices can map subsets of I/O space to processes • Buffer queues (i.e. network cards)

28. Interacting with Device Controllers • How to know when I/O is complete? • Polling • Disadvantage: Busy Waiting • CPU cycles wasted when I/O is slow • Often need to be careful with timing • Interrupts • Goal: Enable asynchronous events • Device signals CPU by asserting interrupt request line • CPU automatically jumps to Interrupt Service Routine • Interrupt vector: Table of ISR addresses • Indexed by interrupt number • Lower priority interrupts postponed until higher priority finished • Interrupts can nest • Disadvantage: Interrupts “interrupt” processing • Interrupt storms

29. Device Driver: Data transfer • Programmed I/O (PIO) • Initiate operation and read in every byte/word of data • Direct Memory Access (DMA) • Offload data xfer work to special-purpose processor • CPU configures DMA transfer • Writes DMA command block into main memory • Target addresses and xfer sizes • Give command block address to DMA engine • DMA engine xfers data from device to memory specified in command block • DMA engine raises interrupt when entire xfer is complete • Virtual or Physical address?