Slide 6-1. Processes. Operating Systems: A Modern Perspective, Chapter 6. Copyright 2004 Pearson Education, Inc.

Transcription

1 Slide es

2 Announcements Slide 6-2 Extension til Friday 11 am for HW #1 Previous lectures online Program Assignment #1 online later today, due 2 weeks from today Homework Set #2 online later today, due a week from today Read chapter 6

3 What is a? Slide 6-3 A software program consist of a sequence of code instructions and data for now, let a simple app = a program CPU executes the instructions line by line in fetch-execute cycle from RAM code instructions operate on data A program is a passive entity A process is a program actively executing from main memory Program P1 Code Data

4 Loading and Executing a Program Slide 6-4 P1 binary Code Disk OS Loader P2 binary Code Main Memory Program P1 binary Code Fetch Code and Data Registers CPU Execution Program Counter (PC) ALU Data Data Data Write Data

5 A process is a program actively executing from main memory has a Program Counter (PC) and execution state associated with it CPU registers keep state OS keeps process state in memory it s alive! has an address space associated with it a limited set of (virtual) addresses that can be accessed by the What is a? executing code Main Memory Program P1 binary Code Data Fetch Code and Data Registers Write Data Slide 6-5 CPU Execution Program Counter (PC) ALU

6 What is a? Slide processes may execute the same program code, but they are considered separate execution sequences Main Memory Program P1 binary Code Data Fetch Code and Data Registers Write Data CPU Execution Program Counter (PC) ALU

7 How is a Structured in Slide 6-7 Main Memory P1 Code Data Memory? float f4=3.0; main() { char* ptr; ptr = malloc(); foo1(); } foo1() { int a1;... } global variables dynamically allocated variables functions local variables

8 How is a Structured in Slide 6-8 Main Memory P1 Code Data Heap Stack Memory? float f4=3.0; main() { char* ptr; ptr = malloc(); foo1(); } foo1() { int a1;... } global variables dynamically allocated variables functions local variables

9 How is a Structured in Slide 6-9 Run-time memory image Essentially code, data, stack, and heap Code and data loaded from executable file Stack grows downward, heap grows upward Memory? max address address 0 Run-time memory User stack Unallocated Heap Read/write.data,.bss Read-only.init,.text,.rodata

10 Why Allocate Local Variables on a Slide 6-10 Stack? Strawman approach: pre-allocate all local variables a priori before a process starts executing, just like global variables What s wrong with this strawman? if a function is never called, then you ve wasted space allocating its local variables don t know a priori how many instances of a local variable to allocate if a function calls itself, i.e. recursion

11 Why Allocate Local Variables on a Slide 6-11 Stack? So allocate local variables only on an asneeded basis A stack provides a simple way to allocate local variables as needed When a function is called, allocate its local variables on top of the stack - push them on the stack when a function completes, deallocate these local variables - pop them off the stack

12 Why Allocate Dynamic Variables Slide 6-12 on a Heap in the s Address Space? Strawman II: could ask the OS to allocate dynamic variables anywhere in memory very complex keeping tracking of all the different locations in memory Keeping the dynamic variables in one area (the process s heap) associated with the process s address space simplifies memory management

13 A Executes in its Own Slide 6-13 Main Memory P1 Code Address Space OS tries to provide the illusion or abstraction that the process executes in its own address space, on its own CPU Data Heap Stack

14 Implementing the Abstraction Slide 6-14 P i CPU P j CPU P k CPU P i Executable i Executable Memory Memory P j Executable j Executable Memory Memory P k Executable k Executable Memory Memory OS interface CPU ALU Control Unit OS OSAddress Space Space P i Address i Address Space Space P k Address k Address Space Space P j Address j Address Space Space Machine Executable Memory

15 OS Management: External View Slide 6-15 Application wait() fork() exec() CreateThread() CloseHandle() Create() WaitForSingleObject() UNIX Device Mgr Mgr Memory Mgr File Mgr Device Mgr Mgr Memory Mgr File Mgr Windows Hardware

16 Manager Responsibilities Slide 6-16 Define & implement the essential characteristics of a process and thread Algorithms to define the behavior Data structures to preserve the state of the execution Define what things threads in the process can reference the address space (most of the things are memory locations) Manage the resources used by the processes/threads Tools to create/destroy/manipulate processes & threads Tools to time-multiplex the CPU Scheduling the (Chapter 7) Tools to allow threads to synchronization the operation with one another (Chapters 8-9) Mechanisms to handle deadlock (Chapter 10) Mechanisms to handle protection (Chapter 14)

17 Manager Overview Slide 6-17 Program Abstract Computing Environment Device Manager File Manager Memory Manager Deadlock Protection Synchronization Scheduler Description Resource Resource Manager Resource Manager Manager Devices Memory CPU Other H/W

18 OS Management Slide 6-18 Main Memory P1 Code Data Heap Stack OS keeps a Control Block (PCB) for each process: state: new, running, waiting, ready, terminated Program counter CPU registers CPU-scheduling information, e.g. priority memory management info: value of base and limit registers, page tables, segment tables I/O info: open files, etc.

19 Multiple es Slide 6-19 Main Memory P1 Code Data Heap Stack P2 Code Data Heap Stack Each process is in memory Only one process at a time executes on the CPU OS provides the mechanisms to switch between processes this is called a context switch

20 Context Switching Slide 6-20 Interrupt Initialization Executable Memory 2 Manager Interrupt Handler P 1 P 2 P n Each time a process is switched out, its context must be saved, e.g. in the PCB Each time a process is switched in, its context is restored This usually requires copying of registers

21 Context Switches Slide 6-21 A context switch can occur because of a system call an I/O interrupt, e.g. disk has finished reading a timer interrupt this is how you implement multitasking Set a timer in the CPU for periodic interrupt, say every 1 ms On an interrupt, go to the timer interrupt handler, e.g. the scheduler, and switch to another process in the ready queue Context switch time is pure overhead it is the price you pay for multiprogramming typically a few milliseconds

22 Multiple es: State Diagram Slide 6-22 Done Request Request Running Schedule Allocate Start Blocked Ready

23 Communicating Between es Slide 6-23 Inter- Communication or IPC would like two processes to share information between them shared file split a single application into multiple processes to speed up execution by allowing overlapped I/O split an application into multiple processes for modularity of coding if address spaces are completely isolated from one another, then how do we share data?

24 Communicating Between es Slide 6-24 Two types of IPC shared memory - OS provides mechanisms that allow creation of a shared memory buffer between processes shmget() creates a shared memory segment, using a name (key ID) shmctl() to modify control information and permissions related to a shared memory segment shmat() to attach a shared memory segment to a process s address space allows fast and high volume reading/writing of buffer in memory applies to processes on the same machine message passing - OS provides constructs that allow communication via buffers typically implemented via system calls, and is hence slower than shared memory sending process has a buffer to send/receive messages, as does the receiving process used to pass small messages extends to communicating between processes on different machines

25 Communicating Between es Slide 6-25 Shared access to the same memory introduces complexity need to synchronize access Producer-Consumer example if two producers write at the same time to shared memory, then they can overwrite each other s data if a producer writes while a consumer is reading, then the consumer may read inconsistent data