• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Process management
 

Process management

on

  • 1,068 views

 

Statistics

Views

Total Views
1,068
Views on SlideShare
1,068
Embed Views
0

Actions

Likes
0
Downloads
11
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Process management Process management Presentation Transcript

    • Submitted by Digpal Singh Jhala MSc IT Sem II 2009-2011 Submitted to Ms. Namita Jain MADAM
      • A program in exucution(process).
      • Sequential manner.
      • At a time only one instruction.
      • Process is more than a program tool.
      • It include current activity as represented by the value of program counter.& process state containing global variables.
      • Program itself is not process.
      • Each process provides the resources needed to execute a program
      • A thread is the entity within a process that can be scheduled for execution.
      • preemptive multitasking
      • A job object allows groups of processes to be managed as a unit. Job objects are namable, securable, sharable objects that control attributes of the processes associated with them
      • An application can use the thread pool to reduce the number of application threads and provide management of the worker threads
      • User-mode scheduling (UMS) is a light-weight mechanism that applications can use to schedule their own threads.
      • A fiber is a unit of execution that must be manually scheduled by the application. Fibers run in the context of the threads that schedule them
    •  
    • Unix process Threads within a unix process
    • Consider An Executing Program
      • Sometimes we call a program in the system a job or a process
      • We speak of the terms process and job interchangeably sometimes, but they are different
      • A job is an activity submitted to the operating system to be done
      • A process is an activity being worked on by the system
      • Thus {processes} {jobs}
    • Basic Program Execution
      • When a program runs, the program counter keeps track of the next instruction to be executed
      • registers keep values of current variables
        • together the program counter and variables for a program are the program state
      • stack space in memory is used to keep values of variables from subroutines that have to be returned to
    •  
    • Process States
      • A process may go through a number of different states as it is executed
      • When a process requests a resource, for example, it may have to wait for that resource to be given by the OS
      • In addition to I/O, memory, and the like, processes must share the CPU
        • processes are “unaware” of each others CPU usage
        • virtualization allows them to share the CPU
    • The Five State Model READY NEW WAITING RUNNING TERMINATED admitted time-out interrupt OS services request I/O or event wait scheduler dispatch deallocate resources and exit Arc labels show typical events which cause that transition
    • Which state is my job in?
      • On some systems , you can look at the status of your jobs and even others’ jobs
        • on UNIX, type ps at the prompt
        • Note: “nice” command in UNIX
        • print jobs on Mac or Windows
      • The number of states possible may differ from our model—after all, it is only a model
    • Context Switching
      • Strictly speaking, only one process can run on the CPU at any given time
      • To share the CPU, the operating system must save the state of one process, then load another’s program and data
      • Hardware has to help with the stopping of programs (time-out interrupt)
      • This context switch does no useful work—it is an overhead expense
    • Process Control Block (PCB)
      • Is a small data structure for the job submitted to the operating system
      • Contents (four major parts):
        • unique identification
        • process status (ie: where in 5 state model)
        • process state (ie: instruction counter, memory map, list of resources allocated, priority)
        • other useful information (eg: usage stats)
      • Schedulers use instead of entire process (why?)
    • Threads versus Processes
      • A thread is a single path of instruction in a program
        • threads share a process!
      • All threads in a process share memory space and other resources
      • Each thread has its own CPU state (registers, program counter) and stack
      • May be scheduled by the process or by the kernel
      • Threads are efficient, but lack protection from each other
    • Program Code (note only one copy needed) Thread 1 Thread 2 PC PC Program Stack Stack Shared Data
    • Types of Threads
      • User Threads
        • Designed for applications to use
        • Managed by application programmer
        • May not get used!
      • Kernel Threads
        • Managed by OS
        • More overhead
    • CPU scheduling policies
      • Many conflicting goals: maximum number of jobs processed, importance of the jobs, responsiveness to users, how long a job might be forced to wait, I/O utilization, CPU utilization, etc.
      • Preemptive versus Nonpreemptive policies
    • Categories of policies
      • Multi-user CPU scheduling policies
        • variants of Round Robin (preemptive)
      • Batch systems
        • First Come, First Served (nonpreemptive)
        • Shortest Job First (nonpreemptive)
        • Shortest Remaining Time (preemptive)
        • Priority Scheduling (preemptive)
    • Round Robin
      • Almost all computers today use some form of time-sharing , even PCs
      • Time divided into CPU quanta (5-100 ms)
      • “ Proper” time quantum size? Two rules of thumb:
        • At least 100 times larger than a context switch
        • (if not, context switch takes too much time)
        • At least 80% of CPU cycles allocated run to completion
        • (if not, RR degenerates towards FCFS)
    • So How Are Processes Scheduled?
      • Let’s assume that we know the arrival times of the jobs, and how many CPU cycles each will take; for RR, assume quantum = 2
      • Real processors don’t know arrival times and CPU cycles required in advance, so we can’t schedule on this basis!
      • Let’s try out some of the algorithms…
    • Simple Example 0 4 5 7 A B C D 10 3 5 2 Arrives: Job: CPU Cycles:
    • Round Robin (RR), First Stages A 0 2 4 A
    • Round Robin, Continued (2) A 0 2 4 6 8 A B C
    • Round Robin, Completed A B C D A B A C A C A 0 2 4 6 8 10 12 13 15 17 18 20
    • Simple Example 0 4 5 7 A B C D 10 3 5 2 Arrives: Job: CPU Cycles:
    • Shortest Remaining Time (SRT) (also preemptive) A D A C B 0 4 7 9 14 20
    • Shortest Job Next (SJN) (non-preemptive) A D C B 0 10 12 15 20
    • First Come, First Served (FCFS) (non-preemptive) A D C B 0 10 13 18 20
    • Turnaround Time
      • Is the time from job arrival to job completion
        • T(j i ) = Finish(j i ) - Arrive(j i )
        • (and where might such information be stored?)
      • We often want to know what the average turnaround time is for a given schedule
      • Let’s calculate the turnaround time for the last schedule…
    • Calculating Average Turnaround Time for FCFS AVERAGE = 11.25 Job: Arrives: Finishes: Turnaround: A B C D 0 4 5 7 10 13 18 20 10 9 13 13
    • Simple Example (Extended) here higher priority values mean you go first… 0 4 5 7 A B C D 10 3 5 2 Arrives: Job: CPU Cycles: Priority: 3 1 4 2
    • Multilevel Priority
      • Many different priority levels, 1, 2, 3, …n where 1 is lowest and n is highest
      • A process is permanently assigned to one priority level
      • A RR scheduler handles processes of equal priority within a level
    • Multilevel Priority (ML) (preemptive) A C A D B 0 5 10 15 17 20 since each process was in a different queue, we didn’t have to calculate RR within the queue
    • Multilevel Feedback (MLF) (preemptive)
      • There are several priority levels 1, 2, … n
      • Processes start at the highest priority level n
      • A maximum time T is associated with each level—if the process uses more than that amount of time, it moves to a lower priority level
      • RR is used to schedule within each level
      • Top levels should be close to pure RR (for good response time),
      • bottom queues should be close to pure FCFS (for good throughput).
      • Both can be achieved if all levels are SRR with varying parameters.
    • Multilevel Feedback Time Limits
      • The time limit at each priority level varies as a function of level
        • T P = T for P = n
        • T P = 2T P+1 for 1 ≤ P < n
        • Usually T is set to some small, reasonable amount appropriate for the particular system
      • If a process uses up time available at level 1, it is assumed to be a runaway process and is terminated
    • Simple Example (Extended) here higher priority values mean you go first… 0 4 5 7 A B C D 10 3 5 2 Arrives: Job: CPU Cycles: Priority: 3 1 4 2
    • Multilevel Feedback Schedule Assumptions: T = 2; RR Quantum = 2 at each level A B C D 1 2 1 1 1 A 2 2 2 3 B C A 0 2 4 6 8 10 12 13 16 20
      • THANKYOU