操作系统基础：系统调用与分时系统特性

需积分: 0 86 浏览量更新于2024-06-30 收藏 2.68MB PDF 举报

操作系统习题解析1涵盖了操作系统基础概念和常见功能的理解。本篇习题集包含多个关于操作系统的关键知识点： 1. 分时系统：题目询问属于分时系统的选项，()C.UNIX被标记为正确答案。分时系统允许多个用户同时共享计算机资源，提供交互式操作环境。 2. 系统调用：用户通过()D.系统调用获得程序级别的系统帮助，这是为了请求操作系统服务的一种机制，通常以标准化的方式进行。 3. 批处理系统缺点：批处理系统的主要缺点是()B.失去了交互性，因为它在没有用户直接干预的情况下运行任务。 4. DOS操作系统功能：()A.文件管理程序是DOS的核心功能，负责文件的创建、读写和管理。 5. Pascal中的sin(x)：()B.标准子程序，表示这可能是Pascal编程语言中调用的一个内置数学函数，而不是系统调用或操作系统命令。 6. 操作系统功能：()D.控制、管理计算机系统的资源和程序的执行是操作系统的核心职责，它协调硬件和软件之间的交互。 7. 分时系统响应时间：在分时系统中，()B.用户数越多，响应时间通常会增加，因为每个用户都会占用一部分时间片。 8. 硬中断、异常和系统调用：它们的相同点在于都是请求操作系统处理特定事件的方式，不同点在于硬中断由硬件触发，异常通常涉及程序错误，而系统调用是由用户程序主动发起的。至于代码段，"pushl%esp"的作用是将当前栈指针（esp）压入堆栈，以保存现场信息以便于trap()函数的正确执行。这些习题旨在帮助学习者深入理解操作系统的基本原理和操作，包括用户界面、资源管理、系统调用机制等，有助于提升对操作系统内部工作方式的掌握。

在一个盒子里，混装了数量相等的黑白围棋子·现在用自动分拣系统把黑子、白子分开，设分拣系统有二个进程P1 和P2 ，其中P1 拣白

子；P2

拣黑子。规定每个进程每次拣一子；当一个进程在拣时，不允许另一个进程去拣；当一个进程拣了一子时，必须让另一个进程去拣．

试写出两进程P1 和P2

能并发正确执行的程序。

[x]

知识点:同步互斥

出处:网络

难度:1

大家熟悉了生产-消费问题(PC)，这个问题很简单。题目较为新颖，但是本质非常简单即：生产-消费问题的简化或者说是两个进程的简

单同步问题。答案如下：

设公共汽车上，司机和售票员的活动分别如下：司机的活动：启动车辆：正常行车；到站停车。售票员的活动：关车门；售票；开车

门。在汽车不断地到站、停车、行驶过程中，

这两个活动有什么同步关系？用信号量和P 、V 操作实现它们的同步。

[x]

知识点:同步互斥

出处:网络

难度:1

在汽车行驶过程中，司机活动与售票员活动之间的同步关系为：售票员关车门后，向司机发开车信号，司机接到开车信号后启动车

辆，在汽车正常行驶过程中售票员售票，到站时

司机停车，售票员在车停后开门让乘客上下车。因此，司机启动车辆的动作必须与售票员关车门的动作取得同步；售票员开车门的动

作也必须与司机停车取得同步。应设置两个信

号量：S1 、S2 ;

S1表示是否允许司机启动汽车（其初值为0 )

S2表示是否允许售票员开门（其初值为0 ）

用P 、v 原语描述如下：

   go T to L;

  p(M);

   go into M;

  V(L);

  P(k);

   go K to s;

  V(M);

  V(k);

  V(T2N);

 end

 Procedure Bike N2T

 begin

  P(N2T);

  p(k);

   go v to k;

  p(M);

   go into M;

  V(k);

  P(L);

   go L to T;

  V(M);

  V(L);

  V(N2T);

 end

coend

设信号量s1 和s2 分别表示可拣白子和黑子;

不失一般性，若令先拣白子。

var S1 , S2 : semaphore;

S1 : = l; S2 ：=0;

cobegin

 process P1      process P2

 begin         begin

  repeat        repeat

   P(S1);        p(S2);

   pick The white;    pick the black;

   V(S2);        v(s1);

  until false;     until false;

 end          end

coend

var S1,S2 : semaphore ;

  S1=0；S2=0；

cobegin

Procedure driver  Procedure Conductor

 begin        begin

 while TRUE      while TRUE

 begin         begin

某寺庙，有小和尚、老和尚若干．庙内有一水缸，由小和尚提水入缸，供老和尚饮用。水缸可容纳10桶水，每次入水、取水仅为1

桶，不可同时进行。水取自同一井中，水井径

窄，每次只能容纳一个水桶取水。设水桶个数为3个，试用信号灯和PV操作给出老和尚和小和尚的活动。

[x]

知识点:同步互斥

出处:网络

难度:1

从井中取水并放入水缸是一个连续的动作可以视为一个进程，从缸中取水为另一个进程。

设水井和水缸为临界资源，引入mutex1,mutex2；三个水桶无论从井中取水还是放入水缸中都一次一个，应该给他们一个信号量

count，抢不到水桶的进程只好

为等待，水缸满了时，不可以再放水了。设empty控制入水量，水缸空了时，不可取水设full。

I/O请求完成会导致哪种进程状态演变？

( ) A.就绪 → 执行

(x) B.阻塞 → 就绪

( ) C.阻塞 → 执行

( ) D.执行 → 阻塞

知识点:操作系统概述

出处:网络

难度:1

一座小桥(最多只能承重两个人)横跨南北两岸，任意时刻同一方向只允许一人过桥，南侧桥段和北侧桥段较窄只能通过一人，桥中央一

处宽敞，允许两个人通过或歇息。试用信

号灯和PV操作写出南、北两岸过桥的同步算法。

[x]

知识点:同步互斥

出处:网络

难度:1

桥上可能没有人，也可能有一人，也可能有两人。

两人同时过桥

两人都到中间

南(北)来者到北(南)段

共需要三个信号量，load用来控制桥上人数，初值为2，表示桥上最多有2人；north用来控制北段桥的使用，初值为1，用于对北段桥

互斥；south用来控制南段

桥的使用，初值为1，用于对南段桥互斥。

  P(S1);        关车门；

  Start;        v(s1);

  Driving;       售票；

  Stop;         p(s2);

  V(S2);        开车门；

 end           上下乘客；

end            end

            end

coend

var mutex1,mutex2,empty,full,count:semaphore;

mutex1:=mutex2:=1;

empty:=10;

full:=0;

count:=3;

cobegin

 Procedure Fetch_Water   Procedure Drink_Water

  begin           begin

  while true         while true

   p(empty);          p(full);

   P(count);          p(count);

   P(mutex1);         p(mutex2);

    Get Water;         Get water and

   v(mutex1);          Drink water;

   P(mutex2);         p(mutex2);

   pure water into the jar;  v(empty);

   v(mutex2);         v(count);

   v(count);         end

   v(full);

  end

coend

var load,north,south:semaphore;

load=2;

north=1;

south=1;

两人公用一个账号，每次限存或取10元；

[x]

知识点:同步互斥

出处:网络

难度:1

某高校计算机系开设网络课并安排上机实习，假设机房共有2m台机器，有2n名学生选课（m，n均大于等于1），规定：

每两个学生组成一组，各占一台及其协同完成上机实习；

只有一组两个学生到齐，并且此时机房有空闲机器时，该组学生才能进入机房；

上机实习由一名教师检查，检查完毕，一组学生同时离开机房

试用P、V实现其过程。

注意：

本题目隐含一个进程(Guard )。

[x]

知识点:同步互斥

出处:网络

难度:1

  GO_South()

   P(load);

   P(north);

    过北段桥;

    到桥中间;

   V(north);

   P(south);

    过南段桥;

    到达南岸;

   V(south);

   V(load);

  GO_North()

   P(load);

   P(south);

    过南段桥;

    到桥中间

   V(south);

   P(north);

    过北段桥;

    到达北岸

   V(north);

   V(load);

begin

var mutex=1:semaphore;

amount =0:integer;

cobegin

 process save

  m1: integer;

  begin

  repeat

  p(mutex);

  m1= amount ;

  m1 = m1 +10;

  amout = m1;

  v(mutex);

  end

 process take

  m2: integer;

  begin

  repeat;

  p(mutex);

  m2= amount ;

  m2 = m2 -10;

  amout = m2;

  v(mutex);

  end

coend

var stu,computer,enter,finish,test:semaphore;

ste:=2N;

computer:=2M;

enter:=0;

finish:=0;

test:=0;

cobegin

Procedure Student  Procedure Teacher  Procedure Guard

 begin        begin        begin

 p(computer);    p(finish);      p(stu);

 p(stu);       Test the work;    p(stu);

  Start computer;  v(test);        Enter;

 v(finish);     v(test);       v(enter);

(18分)调度器是操作系统内核中依据调度算法进行进程切换选择的模块。

1）试描述步进调度算法(Stride Scheduling)的基本原理。

2）请补全下面 ucore代码中调度器和步进调度算法实现中所缺代码，以实现调度器和调度算法的功能。提示：每处需要补全的代码最

少只需要一行，一共有9个空要填。

当然，你可以在需要补全代码的地方写多行来表达需要实现的功能，也允许修改已给出的代码。

3）试描述斜堆(skew heap)在这个步进调度算法中的作用。

```

kern/process/proc.h

==================== kern/process/proc.h ========================

#ifndef KERN_PROCESS_PROC_H

#deﬁne KERN_PROCESS_PROC_H

#include

// process's state in his life cycle

enum proc_state {

PROC_UNINIT = 0, // uninitialized

PROC_SLEEPING, // sleeping

PROC_RUNNABLE, // runnable(maybe running)

PROC_ZOMBIE, // almost dead, and wait parent proc to reclaim his resource

};

// Saved registers for kernel context switches.

// Don't need to save all the %fs etc. segment registers,

// because they are constant across kernel contexts.

// Save all the regular registers so we don't need to care

// which are caller save, but not the return register %eax.

// (Not saving %eax just simpliﬁes the switching code.)

// The layout of context must match code in switch.S.

struct context {

uint32_t eip;

uint32_t esp;

uint32_t ebx;

uint32_t ecx;

uint32_t edx;

uint32_t esi;

uint32_t edi;

uint32_t ebp;

};

#deﬁne PROC_NAME_LEN 15

#deﬁne MAX_PROCESS 4096

#deﬁne MAX_PID (MAX_PROCESS 2)

extern list_entry_t proc_list;

struct proc_struct {

enum proc_state state; // Process state

int pid; // Process ID

int runs; // the running times of Proces

uintptr_t kstack; // Process kernel stack

volatile bool need_resched; // bool value: need to be rescheduled to release CPU?

struct proc_struct parent; // the parent process

struct mm_struct mm; // Process's memory management ﬁeld

struct context context; // Switch here to run process

struct trapframe tf; // Trap frame for current interrupt

uintptr_t cr3; // CR3 register: the base addr of Page Directroy Table(PDT)

uint32_t ﬂags; // Process ﬂag

char name[PROC_NAME_LEN + 1]; // Process name

list_entry_t list_link; // Process link list

list_entry_t hash_link; // Process hash list

int exit_code; // exit code (be sent to parent proc)

uint32_t wait_state; // waiting state

struct proc_struct cptr, yptr, optr; // relations between processes

struct run_queue rq; // running queue contains Process

list_entry_t run_link; // the entry linked in run queue

int time_slice; // time slice for occupying the CPU

skew_heap_entry_t lab6_run_pool; // FOR LAB6 ONLY: the entry in the run pool

uint32_t lab6_stride; // FOR LAB6 ONLY: the current stride of the process

uint32_t lab6_priority; // FOR LAB6 ONLY: the priority of process, set by lab6_set_priority(uint32_t)

};

#deﬁne PF_EXITING 0x00000001 // getting shutdown

#deﬁne WT_CHILD (0x00000001 | WT_INTERRUPTED)

#deﬁne WT_INTERRUPTED 0x80000000 // the wait state could be interrupted

 v(test);      end          v(enter);

 v(computer);              end

 end

coend

#deﬁne le2proc(le, member) \

to_struct((le), struct proc_struct, member)

extern struct proc_struct idleproc, initproc, current;

void proc_init(void);

void proc_run(struct proc_struct proc);

int kernel_thread(int (fn)(void ), void arg, uint32_t clone_ﬂags);

char set_proc_name(struct proc_struct proc, const char name);

char get_proc_name(struct proc_struct proc);

void cpu_idle(void) attribute((noreturn));

struct proc_struct ﬁnd_proc(int pid);

int do_fork(uint32_t clone_ﬂags, uintptr_t stack, struct trapframe tf);

int do_exit(int error_code);

int do_yield(void);

int do_execve(const char name, size_t len, unsigned char binary, size_t size);

int do_wait(int pid, int code_store);

int do_kill(int pid);

void lab6_set_priority(uint32_t priority);

#endif / !KERN_PROCESS_PROC_H /

=============================================================

kern/schedule/default_sched.c

=============kern/schedule/default_sched.c========================

#include

#deﬁne USE_SKEW_HEAP 1

/ You should deﬁne the BigStride constant here/

/ LAB6: YOUR CODE /

#deﬁne BIG_STRIDE 0x7FFFFFFF / ??? /

/ The compare function for two skew_heap_node_t's and the

corresponding procs/

static int

proc_stride_comp_f(void a, void b)

{

struct proc_struct p = le2proc(a, lab6_run_pool);

struct proc_struct q = le2proc(b, lab6_run_pool);

int32_t c = p->lab6_stride - q->lab6_stride;

if (c > 0) return 1;

else if (c == 0) return 0;

else return -1;

}

stride_init initializes the run-queue rq with correct assignment for

member variables, including:

   - run_list: should be a empty list after initialization.

   - lab6_run_pool: NULL

   - proc_num: 0

   - max_time_slice: no need here, the variable would be assigned by the caller.

 

  hint: see proj13.1/libs/list.h for routines of the list structures.

  /

 static void

 stride_init(struct run_queue rq) {

    / LAB6: YOUR CODE /

    list_init(&(rq->run_list));

    rq->lab6_run_pool = NULL;

    rq->proc_num = 0;

 }

 /

  stride_enqueue inserts the process ``proc'' into the run-queue

  ``rq''. The procedure should verify/initialize the relevant members

  of ``proc'', and then put the ``lab6_run_pool'' node into the

  queue(since we use priority queue here). The procedure should also

  update the meta date in ``rq'' structure.

 

  proc->time_slice denotes the time slices allocation for the

  process, which should set to rq->max_time_slice.

 

  hint: see proj13.1/libs/skew_heap.h for routines of the priority

  queue structures.

  /

 static void

 stride_enqueue(struct run_queue rq, struct proc_struct proc) {

    / LAB6: YOUR CODE /

 #if USE_SKEW_HEAP

    rq->lab6_run_pool = ……(1)……;

 #else

    assert(list_empty(&(proc->run_link)));

    list_add_before(&(rq->run_list), &(proc->run_link));

剩余213页未读，继续阅读

阿葱的葱白

粉丝: 30
资源: 311

操作系统基础：系统调用与分时系统特性

操作系统习题解析

操作系统习题与解析

操作系统习题1

王道操作系统习题pdf

北邮操作系统习题答案 csdn

战德臣数据库mooc模拟练习题解析

出10道大学信号与系统填空练习题及解析答案

计算机组成原理实验指导与习题解析 谭志虎pdf

谭志虎 计算机组成原理实验指导与习题解析 pdf

计算机操作系统慕课版pdf

最新资源

计算机组成原理实验指导与习题解析谭志虎pdf

谭志虎计算机组成原理实验指导与习题解析 pdf