CSE 451: Operating Systems Winter 2007 Module 4 Processes

Slides:



Advertisements
Similar presentations
Processes and Threads Prof. Sirer CS 4410 Cornell University.
Advertisements

CSE 451: Operating Systems Winter 2007 Module 4 Processes Ed Lazowska Allen Center 570.
IT344 – Operating Systems Winter 2011, Dale Rowe.
CSE 451: Operating Systems Winter 2006 Module 4 Processes Ed Lazowska Allen Center 570.
Processes CSCI 444/544 Operating Systems Fall 2008.
CSE 451: Operating Systems Winter 2009 Module 4 Processes Mark Zbikowski Gary Kimura.
Chapter 3 Processes 1.
Process in Unix, Linux and Windows CS-3013 C-term Processes in Unix, Linux, and Windows CS-3013 Operating Systems (Slides include materials from.
CS-502 Fall 2006Processes in Unix, Linux, & Windows 1 Processes in Unix, Linux, and Windows CS502 Operating Systems.
CSSE Operating Systems
CSE451 Processes Spring 2001 Gary Kimura Lecture #4 April 2, 2001.
Unix & Windows Processes 1 CS502 Spring 2006 Unix/Windows Processes.
Processes April 5, 2000 Instructor: Gary Kimura Slides courtesy of Hank Levy.
Process Concept An operating system executes a variety of programs
1 Process Description and Control Chapter 3 = Why process? = What is a process? = How to represent processes? = How to control processes?
Process Description and Control A process is sometimes called a task, it is a program in execution.
Processes in Unix, Linux, and Windows CS-502 Fall Processes in Unix, Linux, and Windows CS502 Operating Systems (Slides include materials from Operating.
Process. Process Concept Process – a program in execution Textbook uses the terms job and process almost interchangeably A process includes: – program.
CSE 451: Operating Systems Spring 2012 Module 4 Processes Ed Lazowska Allen Center 570.
CSE 451: Operating Systems Autumn 2013 Module 6 Review of Processes, Kernel Threads, User-Level Threads Ed Lazowska 570 Allen.
CSE 451: Operating Systems Winter 2012 Processes Mark Zbikowski Gary Kimura.
Process in Unix, Linux, and Windows CS-3013 A-term Processes in Unix, Linux, and Windows CS-3013 Operating Systems (Slides include materials from.
Implementing Processes and Process Management Brian Bershad.
Exec Function calls Used to begin a processes execution. Accomplished by overwriting process imaged of caller with that of called. Several flavors, use.
Multiprogramming CSE451 Andrew Whitaker. Overview Multiprogramming: Running multiple programs “at the same time”  Requires multiplexing (sharing) the.
Processes and Threads CS550 Operating Systems. Processes and Threads These exist only at execution time They have fast state changes -> in memory and.
Computer Architecture and Operating Systems CS 3230: Operating System Section Lecture OS-1 Process Concepts Department of Computer Science and Software.
Lecture 3 Process Concepts. What is a Process? A process is the dynamic execution context of an executing program. Several processes may run concurrently,
ITEC 502 컴퓨터 시스템 및 실습 Chapter 2-1: Process Mi-Jung Choi DPNM Lab. Dept. of CSE, POSTECH.
Multiprogramming. Readings r Silberschatz, Galvin, Gagne, “Operating System Concepts”, 8 th edition: Chapter 3.1, 3.2.
Computer Studies (AL) Operating System Process Management - Process.
CS 153 Design of Operating Systems Spring 2015 Lecture 5: Processes and Threads.
IT 344: Operating Systems Winter 2010 Module 5 Process and Threads
1  process  process creation/termination  context  process control block (PCB)  context switch  5-state process model  process scheduling short/medium/long.
CSE 451: Operating Systems Spring 2010 Module 4: Processes John Zahorjan Allen Center 534.
Multiprogramming. Readings r Chapter 2.1 of the textbook.
Chapter 3: Processes.
Process Management Process Concept Why only the global variables?
Processes.
Protection of System Resources
Lecture Topics: 11/1 Processes Process Management
CSE 451: Operating Systems Autumn 2013 Module 4 Processes
Chapter 3: Processes.
Process Realization In OS
Processes in Unix, Linux, and Windows
IT 344: Operating Systems Module 4 Processes
IT 344: Operating Systems Module 5 Process and Threads
Processes in Unix, Linux, and Windows
Processes in Unix, Linux, and Windows
Operating Systems Lecture 6.
CSE 451: Operating Systems Spring 2012 Module 6 Review of Processes, Kernel Threads, User-Level Threads Ed Lazowska 570 Allen.
Process & its States Lecture 5.
CSE 451: Operating Systems Winter 2011 Processes
CSE 451: Operating Systems Winter 2010 Module 4 Processes
Lecture Topics: 11/1 General Operating System Concepts Processes
Processes Hank Levy 1.
Processes and Process Management
October 7, 2002 Gary Kimura Lecture #4 October 7, 2002
CSE 451: Operating Systems Winter 2003 Lecture 4 Processes
Processes in Unix, Linux, and Windows
CSE 451: Operating Systems Autumn 2009 Module 4 Processes
IT 344: Operating Systems Winter 2008 Module 4 Processes
Processes in Unix and Windows
CS510 Operating System Foundations
CSE 451: Operating Systems Autumn 2004 Module 4 Processes
CSE 451: Operating Systems Spring 2006 Module 4 Processes
CSE 153 Design of Operating Systems Winter 2019
Processes Hank Levy 1.
CSE 451: Operating Systems Autumn 2010 Module 4 Processes
Presentation transcript:

CSE 451: Operating Systems Winter 2007 Module 4 Processes Gary Kimura and Mark Zbikowski 1

Process management This module begins a series of topics on processes, threads, and synchronization this is the most important part of the class there definitely will be several questions on these topics on the midterm Today: processes and process management what are the OS units of ownership / execution? how are they represented inside the OS? how is the CPU scheduled across processes? what are the possible execution states of a process? and how does the system move between them? 2 April, 2007

The process The process is the OS’s abstraction for execution the unit of execution the unit of scheduling the unit of ownership the dynamic (active) execution context compared with program: static, just a bunch of bytes Process is often called a job, task, or sequential process a sequential process is a program in execution defines the instruction-at-a-time execution of a program 2 April, 2007

What’s in a process? A process consists of (at least): an address space the code for the running program the data for the running program an execution stack and stack pointer (SP) traces state of procedure calls made the program counter (PC), indicating the next instruction registers and their values a set of OS resources open files, network connections, sound channels, … In other words, it’s all the stuff you need to run the program or to re-start it, if it’s interrupted at some point 2 April, 2007

The process control block There’s a data structure called the process control block (PCB) that holds all this stuff The PCB is identified by an integer process ID (PID) OS keeps all of a process’s hardware execution state in the PCB when the process isn’t running PC, SP, registers, etc. when a process is unscheduled, the state is transferred out of the hardware into the PCB Note: It’s natural to think that there must be some esoteric techniques being used fancy data structures that’d you’d never think of yourself Wrong! It’s pretty much just what you’d think of! Except for some clever assembly code… 2 April, 2007

Process states Each process has an execution state, which indicates what it is currently doing ready: waiting to be assigned to CPU could run, but another process has the CPU running: executing on the CPU is the process that currently controls the CPU pop quiz: how many processes can be running simultaneously? waiting: waiting for an event, e.g., I/O cannot make progress until event happens As a process executes, it moves from state to state UNIX: run ps, STAT column shows current state which state is a process in most of the time? 2 April, 2007

States of a process running interrupt (unschedule) dispatch / schedule ready exception (I/O, page fault, etc.) interrupt (I/O complete) You can create and destroy processes! blocked 2 April, 2007

The PCB revisited The PCB is a data structure with many, many fields: process ID (PID) execution state program counter, stack pointer, registers address space info UNIX username of owner scheduling priority accounting info pointers for state queues In linux: defined in task_struct (include/linux/sched.h) over 95 fields!!! In Windows XP, 75 fields 2 April, 2007

A process’s address space 0xFFFFFFFF stack (dynamic allocated mem) SP heap (dynamic allocated mem) address space static data (data segment) code (text segment) PC 0x00000000 2 April, 2007

PCBs and hardware state When a process is running, its hardware state is inside the CPU PC, SP, registers CPU contains current values When the OS stops running a process (puts it in the waiting state), it saves the registers’ values in the PCB when the OS puts the process in the running state, it loads the hardware registers from the values in that process’s PCB The act of switching the CPU from one process to another is called a context switch timesharing systems may do 100s or 1000s of switches/sec. takes about 5 microseconds on today’s hardware 2 April, 2007

State queues The OS maintains a collection of queues that represent the state of all processes in the system typically one queue for each state e.g., ready, waiting, … each PCB is queued onto a state queue according to the current state of the process it represents as a process changes state, its PCB is unlinked from one queue, and linked onto another Once again, this is just as straightforward as it sounds! The PCBs are moved between queues, which are represented as linked lists. There is no magic! 2 April, 2007

State queues These are PCBs! Ready queue header firefox pcb emacs pcb ls pcb head ptr tail ptr Wait queue header cat pcb firefox pcb head ptr tail ptr There may be many wait queues, one for each type of wait (particular device, timer, message, …) 2 April, 2007

Program count stack pointer (all) register values This is (a simplification of) what each of those PCBs looks like inside! Process ID Pointer to parent List of children Process state Pointer to address space descriptor Program count stack pointer (all) register values uid (user id) gid (group id) euid (effective user id) Open file list Scheduling priority Accounting info Pointers for state queues Exit (“return”) code value 2 April, 2007

PCBs and state queues PCBs are data structures dynamically allocated inside OS memory When a process is created: OS allocates a PCB for it OS initializes PCB OS puts PCB on the correct queue As a process computes: OS moves its PCB from queue to queue When a process is terminated: PCB may hang around for a while (exit code, etc.) eventually, OS deallocates the PCB 2 April, 2007

Process creation New processes are created by existing processes creator is called the parent created process is called the child UNIX: do ps, look for PPID field what creates the first process, and when? In some systems, parent defines or donates resources and privileges for its children UNIX: child inherits parent’s uid, environment, open file list, etc. When child is created, parent may either wait for it to finish, or may continue in parallel, or both! 2 April, 2007

UNIX process creation UNIX process creation through fork() system call creates and initializes a new PCB creates a new address space initializes new address space with a copy of the entire contents of the address space of the parent initializes kernel resources of new process with resources of parent (e.g., open files) places new PCB on the ready queue the fork() system call “returns twice” once into the parent, and once into the child returns the child’s PID to the parent returns 0 to the child fork() = “clone me” 2 April, 2007

testparent – use of fork( ) #include <sys/types.h> #include <unistd.h> #include <stdio.h> int main(int argc, char **argv) { char *name = argv[0]; int pid = fork(); if (pid == 0) { printf(“Child of %s is %d\n”, name, pid); return 0; } else { printf(“My child is %d\n”, pid); } 2 April, 2007

testparent output spinlock% gcc -o testparent testparent.c spinlock% ./testparent My child is 486 Child of testparent is 0 My child is 571 2 April, 2007

Exec vs. fork So how do we start a new program, instead of just forking the old program? the exec() system call! int exec(char *prog, char ** argv) exec() discards the current address space loads program ‘prog’ into the address space initializes registers, args for new program places PCB onto ready queue note: does not create a new process! 2 April, 2007

UNIX shells int main(int argc, char **argv) { while (1) { char *cmd = get_next_command(); int pid = fork(); if (pid == 0) { manipulate STDIN/STDOUT/STDERR fd’s exec(cmd); panic(“exec failed!”); } else { wait(pid); } 2 April, 2007

Input/output redirection $ ./myprog <input.txt >output.txt # UNIX each process has an open file table by (universal) convention: 0: stdin 1: stdout 2: stderr a child process inherits the parent’s open file table So the shell… copies its current stdin/stdout open file entries opens input.txt as stdin and output.txt as stdout fork… restore original stdin/stdout 2 April, 2007