此博客处内容为 《操作系统导论》(Operating Systems: Three Easy Pieces)第7章:进程调度:介绍,课后作业解析翻译,便于学习。
原书英文版地址 https://pages.cs.wisc.edu/~remzi/OSTEP/
scheduler.py 这个调度程序,允许你查看不同调度器在相应时间(response time),周转时间(turnaround time)和总等待时间等调度指标下的执行情况。程序中实现了三个调度算法:FIFO,SJF和RR。(该调度程序代码将在文章最后附上)
运行该程序需要两步:
首先,在没有 “-c” 标志的情况下运行:这将告诉你要解决什么问题,而不会给出答案。例如,计算响应时间,周转试件,并使用FIFO策略等待三个作业,那么运行如下进程:
>> python scheduler.py -p FIFO -j 3 -s 100
这指定了具有三个作业的FIFO策略,重要的是,指定了一个100的特定随机种子。如果你想知道这个问题的答案,你必须再次指定这个完全相同的随机种子。运行上述代码后得到如下结果
ARG policy FIFO
ARG jobs 3
ARG maxlen 10
ARG seed 100
Here is the job list, with the run time of each job:
Job 0 (length = 1)
Job 1 (length = 4)
Job 2 (length = 7)
Compute the turnaround time, response time, and wait time for each job. When
you are done, run this program again, with the same arguments, but with -c,
which will thus provide you with the answers. You can use -s <somenumber> or
your own job list (-l 10,15,20 for example) to generate different problems for
yourself.
从这个程序中可以看到,生成三个作业(job):长度为1的job 0,长度为4的job 1以及长度为7的job 2。现在可以使用它来计算一些统计数据,看看是否掌握了基本概念。
一旦你完成了,你可以使用相同的程序来“解决”问题,看看你是否正确地做了你的工作。为此,使用"-c"标志。
>> python scheduler.py -p FIFO -j 3 -s 100 -c
ARG policy FIFO
ARG jobs 3
ARG maxlen 10
ARG seed 100
Here is the job list, with the run time of each job:
Job 0 (length = 1)
Job 1 (length = 4)
Job 2 (length = 7)
** Solutions **
Execution trace:
[time 0] Run job 0 for 1.00 secs (DONE)
[time 1] Run job 1 for 4.00 secs (DONE)
[time 5] Run job 2 for 7.00 secs (DONE)
Final statistics:
Job 0 -- Response: 0.00 Turnaround 1.00 Wait 0.00
Job 1 -- Response: 1.00 Turnaround 5.00 Wait 1.00
Job 2 -- Response: 5.00 Turnaround 12.00 Wait 5.00
Average -- Response: 2.00 Turnaround 6.00 Wait 2.00
从图中可以看到,”-c“ 标志显示了所发生的情况。作业0先运行1秒,作业1先运行4秒,然后作业2运行7秒。不是太难;毕竟这是FIFO !执行跟踪显示了这些结果。
最后的统计数据也很有用:它们计算“响应时间”(任务到达后在第一次运行之前所花费的等待时间)、“周转时间”(第一次到达后完成任务所花费的时间)和总“等待时间”(准备就绪但未运行时所花费的时间)。每个工作的统计数据显示,然后作为所有工作的平均值显示。当然,你应该在使用“-c”标志运行之前计算所有这些东西。
如果您想尝试使用不同输入的相同类型的问题,请尝试更改作业数量或随机种子,或两者同时更改。不同的随机种子基本上给了你一种为自己产生无数不同问题的方法,“-c”标志让你检查你自己的工作。一直这样做,直到你觉得你真的理解了这些概念。
另一个有用的标志是“-l”(小写的L),它允许您指定希望看到的调度作业。例如,如果您想了解SJF对于长度为5、10和15的三个作业的性能,您可以运行:
>> python scheduler.py -p SJF -l 5,10,15
ARG policy SJF
ARG jlist 5,10,15
Here is the job list, with the run time of each job:
Job 0 (length = 5.0)
Job 1 (length = 10.0)
Job 2 (length = 15.0)
...
然后你可以用 -c 来求解。请注意,当您指定精确的作业时,不需要指定随机种子或作业数量:作业的长度是从逗号分隔的列表中获取的。当然,当您使用SJF(最短作业优先)或RR(轮询)调度器时,会发生更有趣的事情。
另外通过python scheduler.py -h 获取标志和选项的完整列表(包括设置RR调度程序的时间量等选项)。
附录:scheduler.py 程序代码
#! /usr/bin/env python
import sys
from optparse import OptionParser
import random
parser = OptionParser()
parser.add_option("-s", "--seed", default=0, help="the random seed",
action="store", type="int", dest="seed")
parser.add_option("-j", "--jobs", default=3, help="number of jobs in the system",
action="store", type="int", dest="jobs")
parser.add_option("-l", "--jlist", default="", help="instead of random jobs, provide a comma-separated list of run times",
action="store", type="string", dest="jlist")
parser.add_option("-m", "--maxlen", default=10, help="max length of job",
action="store", type="int", dest="maxlen")
parser.add_option("-p", "--policy", default="FIFO", help="sched policy to use: SJF, FIFO, RR",
action="store", type="string", dest="policy")
parser.add_option("-q", "--quantum", help="length of time slice for RR policy", default=1,
action="store", type="int", dest="quantum")
parser.add_option("-c", help="compute answers for me", action="store_true", default=False, dest="solve")
(options, args) = parser.parse_args()
random.seed(options.seed)
print('ARG policy', options.policy)
if options.jlist == '':
print('ARG jobs', options.jobs)
print('ARG maxlen', options.maxlen)
print('ARG seed', options.seed)
else:
print('ARG jlist', options.jlist)
print('')
print('Here is the job list, with the run time of each job: ')
import operator
joblist = []
if options.jlist == '':
for jobnum in range(0,options.jobs):
runtime = int(options.maxlen * random.random()) + 1
joblist.append([jobnum, runtime])
print(' Job', jobnum, '( length = ' + str(runtime) + ' )')
else:
jobnum = 0
for runtime in options.jlist.split(','):
joblist.append([jobnum, float(runtime)])
jobnum += 1
for job in joblist:
print(' Job', job[0], '( length = ' + str(job[1]) + ' )')
print('\n')
if options.solve == True:
print('** Solutions **\n')
if options.policy == 'SJF':
joblist = sorted(joblist, key=operator.itemgetter(1))
options.policy = 'FIFO'
if options.policy == 'FIFO':
thetime = 0
print('Execution trace:')
for job in joblist:
print(' [ time %3d ] Run job %d for %.2f secs ( DONE at %.2f )' % (thetime, job[0], job[1], thetime + job[1]))
thetime += job[1]
print('\nFinal statistics:')
t = 0.0
count = 0
turnaroundSum = 0.0
waitSum = 0.0
responseSum = 0.0
for tmp in joblist:
jobnum = tmp[0]
runtime = tmp[1]
response = t
turnaround = t + runtime
wait = t
print(' Job %3d -- Response: %3.2f Turnaround %3.2f Wait %3.2f' % (jobnum, response, turnaround, wait))
responseSum += response
turnaroundSum += turnaround
waitSum += wait
t += runtime
count = count + 1
print('\n Average -- Response: %3.2f Turnaround %3.2f Wait %3.2f\n' % (responseSum/count, turnaroundSum/count, waitSum/count))
if options.policy == 'RR':
print('Execution trace:')
turnaround = {}
response = {}
lastran = {}
wait = {}
quantum = float(options.quantum)
jobcount = len(joblist)
for i in range(0,jobcount):
lastran[i] = 0.0
wait[i] = 0.0
turnaround[i] = 0.0
response[i] = -1
runlist = []
for e in joblist:
runlist.append(e)
thetime = 0.0
while jobcount > 0:
# print '%d jobs remaining' % jobcount
job = runlist.pop(0)
jobnum = job[0]
runtime = float(job[1])
if response[jobnum] == -1:
response[jobnum] = thetime
currwait = thetime - lastran[jobnum]
wait[jobnum] += currwait
if runtime > quantum:
runtime -= quantum
ranfor = quantum
print(' [ time %3d ] Run job %3d for %.2f secs' % (thetime, jobnum, ranfor))
runlist.append([jobnum, runtime])
else:
ranfor = runtime;
print(' [ time %3d ] Run job %3d for %.2f secs ( DONE at %.2f )' % (thetime, jobnum, ranfor, thetime + ranfor))
turnaround[jobnum] = thetime + ranfor
jobcount -= 1
thetime += ranfor
lastran[jobnum] = thetime
print('\nFinal statistics:')
turnaroundSum = 0.0
waitSum = 0.0
responseSum = 0.0
for i in range(0,len(joblist)):
turnaroundSum += turnaround[i]
responseSum += response[i]
waitSum += wait[i]
print(' Job %3d -- Response: %3.2f Turnaround %3.2f Wait %3.2f' % (i, response[i], turnaround[i], wait[i]))
count = len(joblist)
print('\n Average -- Response: %3.2f Turnaround %3.2f Wait %3.2f\n' % (responseSum/count, turnaroundSum/count, waitSum/count))
if options.policy != 'FIFO' and options.policy != 'SJF' and options.policy != 'RR':
print('Error: Policy', options.policy, 'is not available.')
sys.exit(0)
else:
print('Compute the turnaround time, response time, and wait time for each job.')
print('When you are done, run this program again, with the same arguments,')
print('but with -c, which will thus provide you with the answers. You can use')
print('-s <somenumber> or your own job list (-l 10,15,20 for example)')
print('to generate different problems for yourself.')
print('')