CSE 5343/7343 Fall 2002 Case Studies UNIX CSE 5343/7343

Slides:



Advertisements
Similar presentations
More on Processes Chapter 3. Process image _the physical representation of a process in the OS _an address space consisting of code, data and stack segments.
Advertisements

Chapter 3 Process Description and Control
1 UNIX 1 History of UNIX 2 Overview of UNIX 3 Processes in UNIX 4 Memory management in UNIX 5 The UNIX file system 6 Input/output in UNIX.
Structure of Processes
Introduction to Operating Systems – Windows process and thread management In this lecture we will cover Threads and processes in Windows Thread priority.
Introduction to Kernel
Home: Phones OFF Please Unix Kernel Parminder Singh Kang Home:
3.5 Interprocess Communication
Advanced OS Chapter 3p2 Sections 3.4 / 3.5. Interrupts These enable software to respond to signals from hardware. The set of instructions to be executed.
1/28/2004CSCI 315 Operating Systems Design1 Operating System Structures & Processes Notice: The slides for this lecture have been largely based on those.
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.
Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition, Chapter 3: Processes.
Chapter 6 Implementing Processes, Threads, and Resources.
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.
Phones OFF Please Processes Parminder Singh Kang Home:
Chapter 51 Threads Chapter 5. 2 Process Characteristics  Concept of Process has two facets.  A Process is: A Unit of resource ownership:  a virtual.
Process Description and Control Chapter 3. Major Requirements of an OS Interleave the execution of several processes to maximize processor utilization.
Process in Unix, Linux, and Windows CS-3013 A-term Processes in Unix, Linux, and Windows CS-3013 Operating Systems (Slides include materials from.
Chapter 41 Processes Chapter 4. 2 Processes  Multiprogramming operating systems are built around the concept of process (also called task).  A process.
Lecture 3 Process Concepts. What is a Process? A process is the dynamic execution context of an executing program. Several processes may run concurrently,
Multiprogramming. Readings r Silberschatz, Galvin, Gagne, “Operating System Concepts”, 8 th edition: Chapter 3.1, 3.2.
Threads G.Anuradha (Reference : William Stallings)
MODERN OPERATING SYSTEMS Third Edition ANDREW S. TANENBAUM Chapter 10 Case Study 1: LINUX Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall,
CSE 5343/7343UNIX Case Study1 CSE 5343/7343 Fall 2006 Case Studies UNIX.
Silberschatz, Galvin and Gagne  Operating System Concepts Process Concept An operating system executes a variety of programs:  Batch system.
CSE 5343/7343UNIX Case Study1 CSE 5343/7343 Fall 2006 Case Studies UNIX History/Processes.
1 Unix Architecture. 2 Operating Systems Concepts 1. Process 2. Memory management 3. Information protection & security 4. Scheduling and resource management.
Processes, Threads, and Process States. Programs and Processes  Program: an executable file (before/after compilation)  Process: an instance of a program.
Process Description and Control Chapter 3. Source Modified slides from Missouri U. of Science and Tech.
1 Structure of Processes Chapter 6 Process State and Transition Data Structure for Process Layout of System Memory THE DESIGN OF THE UNIX OPERATING SYSTEM.
Managing Processors Jeff Chase Duke University. The story so far: protected CPU mode user mode kernel mode kernel “top half” kernel “bottom half” (interrupt.
What is a Process ? A program in execution.
Introduction Contain two or more CPU share common memory and peripherals. Provide greater system throughput. Multiple processor executing simultaneous.
1 Chapter 2: Operating-System Structures Services Interface provided to users & programmers –System calls (programmer access) –User level access to system.
Processes and Threads Chapter 3 and 4 Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee Community College,
Multiprogramming. Readings r Chapter 2.1 of the textbook.
Introduction to Operating Systems Concepts
MODERN OPERATING SYSTEMS Third Edition ANDREW S
Introduction to Kernel
Process Management Process Concept Why only the global variables?
Structure of Processes
Modeling Page Replacement Algorithms
Operating Systems: A Modern Perspective, Chapter 6
Processes in Unix, Linux, and Windows
Structure of Processes
Processes in Unix, Linux, and Windows
Processes in Unix, Linux, and Windows
CHAPTER 8 ( , ) John Carelli, Instructor Kutztown University
Process & its States Lecture 5.
Modeling Page Replacement Algorithms
Process Description and Control
Lecture Topics: 11/1 General Operating System Concepts Processes
Process Description and Control
Lecture 4- Threads, SMP, and Microkernels
Operating Systems Lecture 1.
Process Control B.Ramamurthy 2/22/2019 B.Ramamurthy.
Unix Process Control B.Ramamurthy 4/11/2019 B.Ramamurthy.
Processes in Unix, Linux, and Windows
Implementing Processes, Threads, and Resources
Processes in Unix and Windows
Chapter 2 Processes and Threads 2.1 Processes 2.2 Threads
Process Description and Control in Unix
CSE 153 Design of Operating Systems Winter 2019
Process Description and Control in Unix
Structure of Processes
Mr. M. D. Jamadar Assistant Professor
Presentation transcript:

CSE 5343/7343 Fall 2002 Case Studies UNIX CSE 5343/7343 UNIX Case Study

UNIX Case Study Outline History Design Philosophy Process Management Processes PCB/Process Table/U Area Process States Process Scheduling/Priorities IPC Memory Management File Systems CSE 5343/7343 UNIX Case Study

History ([2],[3]) 1965 – Bell and GE joined project MAC at MIT to develop Multics. Goal: multicomputing and data sharing for a large group of users. Ken Thompson (Bell) developed a game called “Space Travel” and found an unused PDP-7. 1969 Thompson and Ken Ritchie implemented an earlier designed file system on PDP-7. This grew into UNIX. File system design and idea of command interpreter (shell) as a user process came from Multics Fork idea came from Berkeley’s GENIE OS. CSE 5343/7343 UNIX Case Study

History (cont’d) 1971 – UNIX used in first real project: text processing for BELL labs patent department. 1971 – UNIX required 16K bytes for system, 8K bytes for user programs, 512K bytes of disk, and limit of 64K disk bytes per file. Thompson set out to write a new Fortran compiler but developed a new programming language: B. B was based on BCPL (a tool for compiler writing and systems programming). B was interpretive. He later improved on B and called it C. 1973 – UNIX rewrittten in C (unheard of at the time). AT&T offered UNIX free to universities. 1974 – Ritchie and Thompson paper describing UNIX in CACM. CSE 5343/7343 UNIX Case Study

History (cont’d) 1977 - Bell combined several versions into UNIX System II and marketed. History (cont’d) 1978 – After distribution of Ver7 in 1978, the Unix Support Group (USG) at AT&T took over responsibilities from the research for distribution within AT&T. 1982 – First external distribution from USG – System III. UC Berkeley developed their version of UNIX (Berkeley software Distributions). BSD introduced vi in 2BSD, demand-pages virtual memory in 3BSD, TCP/IP networking protocol in 4.2BSD. Less than 3% of BSD written in assembly. 1991 – Finnish student Linus Torvalds wrote Linux for 80386, 32 bit processor CSE 5343/7343 UNIX Case Study

Design Philosophy ([2],[3]) Smplicity C Time-sharing Simple user interface (modular and may be replaced) Device independence (treat files and devices in same manner) Aimed for programming environment Flexibility CSE 5343/7343 UNIX Case Study

Design (cont’d) Fig 1.1 p5 [2] Programs such as shell and vi interact with kernel using well defined system call procedures. Cc built on top of c preprocessor, two-pass compiler. Fig 2.1 p20 [2] CSE 5343/7343 UNIX Case Study

Processes Process is program in execution Consists of machine instructions (text), data, and stack regions. Separate stack for user and kernel mode. PID (Process ID) Processes are either user processes, daemon processes, or kernel processes. Daemons are not associated with user, but do system wide functions. Init may create daemons that exist throughout the life of the system or as needed. CSE 5343/7343 UNIX Case Study

Solaris Threads ([3]) Kernel and user level threads Fig 5.6 p141 [3] Only kernel level threads are scheduled Implements Pthread API LWP between kernel and user level threads Each LWP associated with a kernel thread. User processes have at least one LWP. User threads may be bound or unbound to a LWP. May have kernel thread without LWP. Pool of LWPs for a process CSE 5343/7343 UNIX Case Study

Solaris Threads (cont’d) User level thread Thread ID Registers Stack pointer/stack Priority Process Process ID Memory map Open files LWPs Kernel thread Copy of kernel registers Pointer to LWP Priority Scheduling information Stack LWP Registers Memory Accounting information CSE 5343/7343 UNIX Case Study

PCB ([1],[2],[4]) Process Table: State UID for owner Memory status (swapped or in memory) Parent PID Child PID Event descriptor if suspended Fig 2.5 p28 [2] Entry in kernel process table that points to process region table. These in turn point to entries in the region table and to the regions for that process. This allows independent processes to share regions. Fig 6.2 p153 [2] CSE 5343/7343 UNIX Case Study

U (User) Area ([2]) Information needed when process is executing. Process table slot Information about current system call File descriptors for open files Current directory Current root Login terminal Kernel has direct access to U area of currently executing process. CSE 5343/7343 UNIX Case Study

Process States ([1],[2]) Fig 6.1 p148 [2] No context switch is needed to go from state 2 to state 1. States 3 and 7 are really the same. I/O request puts process to sleep. Zombie state – Child has finished execution, but parent wants to get information about it from the PCB. CSE 5343/7343 UNIX Case Study

Process Hierarchy ([1]) Initial boot process (0) forks a child (process 1) and process 0 becomes the swapper. Process 1 is init process and is ancestor of all other processes. Parent/Child/Sibling relationship indicated by pointers in process table. Execve usually called to replace memory portion of new process. Exit – process termination Wait – Parent waits for child to exit. Reclaims process resources. Process group ID (GID) in process table Execute: ps -alx CSE 5343/7343 UNIX Case Study

Process Scheduling([2],[3],[5]) Typical time slice values: 4.3BSD: 1/10 second (p 86 [2]) System V: 50-100 times per second (p247 [3]) Round robin multilevel feedback queue At end of context switch, kernel executes algorithm to schedule a process. Highest priority process which is ready is scheduled. On tie, picks the one which has waited the longest. CSE 5343/7343 UNIX Case Study

Process Scheduling (cont’d) Higher number – Lower Priority User and kernel priorities; user below kernel. User mode priority is function of recent CPU usage. Lower priority if recently used CPU. Fig 8.2 p250 [2] Priority assigned based on process group CSE 5343/7343 UNIX Case Study

Process Scheduling (cont’d) Kernel to user mode: change to user mode and calculate based on kernel resources just used. Clock Handler adjusts all user mode process priorities at 1 second (System V) intervals and causes kernel to reschedule. Decay function adjusts recent CPU usage values at this time: decay(CPU) = CPU/2 Priority is recalculated at these 1 second intervals plus when a process is in the preempted but ready to run state: priority = CPU/2 + base level priority Base level priority is the threshold between user and kernel mode. Processes move up in queue but can not change to kernel mode. Fig 8.4 p 253 [2] CSE 5343/7343 UNIX Case Study

IPC ([2],[3]) Pipes – Only used from descendents of process that created the pipe. Named Pipes- Used by unrelated processes. Has a directory entry and is accessed as a file. Signals Inform process of occurrence of asynchronous events. Handling of signal by user process. Address of this routine is located in uarea next to signal number. Socket Introduced by 4.2BSD Transient object; Exists only as long as some process holds a descriptor referring to it. Created by socket system call CSE 5343/7343 UNIX Case Study

IPC (cont’d) Messages (System V) Fig 11.5 p363 [2] On sending a message, a new entry is added to the associated linked list and the message is copied form the uarea. Message headers arranged in FIFO order. Kernel awakens processes waiting for a message from this queue. On receiving a message, process indicates what should be done if no message on the queue. CSE 5343/7343 UNIX Case Study

IPC (cont’d) Shared Memory (System V) System call creates a new region of shared memory or returns a current one. Reading and writing is done as normal – no system calls. Fig 11.9 p 368 [2] Shared memory remains in tact even if no processes include it in their virtual address space. CSE 5343/7343 UNIX Case Study

IPC (cont’d) Semaphores (System V) System calls create and use semaphore. Semaphore array where each entry is the count value. If process is put to sleep, it sleeps at an interruptable priority and wakes up on receipt of a signal. Handled similar to messages with id being the entry in the semaphore table. CSE 5343/7343 UNIX Case Study

References Samuel J. Leffler, Marshall Kirk McKusick, Michael J. Karels, and John S. Quarterman, The Design and Implementation of the 4.3 BSD UNIX Operating System, Addison-Wesley, 1989. Maurice J. Bach, The Design of the UNIX Operating System, Prentice Hall, 1990. Abraham Silberschatz, Peter Baer Galvin, and Greg Gagne, Operating System Concepts Sixth Edition, John Wiley & Sons, 2002. Milan Milenkovic, Operating Systems Concepts and Design Second Edition, McGraw Hill, 1992. Andrew S. Tanenbaum, Modern Operating Systems, Prentice Hall, 1992. CSE 5343/7343 UNIX Case Study