操作系统导论期末复习题

进程
进程调度策略和内存虚拟化机制
memory virtualization
并发
Persistance持久化

进程

1、When a process makes a system call to transmit a TCP packet over the network, which of the following steps do NOT occur always?

A、The process moves to kernel mode.

B、The program counter of the CPU shifts to the kernel part of the address space.

C、The process is context-switched out and a separate kernel process starts execution.

D、The OS code that deals with handling TCP/IP packets is invoked.

正确答案： C

2、Which of the following C library functions do NOT directly correspond to (similarly named) system calls? That is, the implentations of which of these C library functions are NOT straightforward invocations of the underlying system call?

A、system, which executes a bash shell command.

B、fork, which creates a new child process.

C、exit, which terminates the current process.

D、strlen, which returns the length of a string.

正确答案： AD

3、Consider a parent process that has forked a child in the code snippet below.

int count = 0;
ret = fork();
if(ret == 0) {
printf(“count in child=%d\n”, count);
} else {
count = 1;
}

The parent executes the statement ”count = 1” before the child executes for the ﬁrst time. Now, what is the value of count printed by the code above? Assume that the OS implements a regular fork (not a copy-on-write fork).

正确答案：
第一空： 0

fork一次调用，两次返回，在子进程中，返回；在父进程中返回新创建的子进程ID；如果出现错误，返回一个负值。这两个进程的变量都是独立的，存在不同的地址中，不是共用的。

4、Consider a parent process P that has forked a child process C in the program below.

int a = 5;
int fd = open(…) //opening a file
int ret = fork();
if(ret > 0) {
close(fd);
a = 6;
…
} else if (ret == 0) {
printf(“a=%d\n”, a);
read(fd, something);
}

After the new process is forked, suppose that the parent process is scheduled ﬁrst, before the child process. Once the parent resumes after fork, it closes the ﬁle descriptor and changes the value of a variable as shown above. Assume that the child process is scheduled for the ﬁrst time only after the parent completes these two changes.
(a)____ is the value of the variable a as printed in the child process, when it is scheduled next.
(b) Will the attempt to read from the ﬁle descriptor succeed in the child? Yes or No

正确答案：
第一空： 5
第二空： Yes

5、Can two processes be concurrently executing the same program executable?

正确答案： √

6、Can two running processes share the complete process image in physical memory (not just parts of it)?

正确答案： ×

7、A process in user mode cannot execute certain privileged hardware instructions.

正确答案： √

8、A context switch can occur only after processing a timer interrupt, but not after any other system call or interrupt.

正确答案： ×

上下文切换（有时也称做进程切换或任务切换）是指 CPU 从一个进程或线程切换到另一个进程或线程。上下文切换只能发生在内核态中。内核态是CPU的一种有特权的模式，在这种模式下只有内核运行并且可以访问所有内存和其他系统资源。其他的程序，如应用程序，在最开始都是运行在用户态，但是他们能通过系统调用来运行部分内核的代码。
上下文切换在多任务操作系统中是一个必须的特性。多任务操作系统是指多个进程运行在一个 CPU 中互不打扰，看起来像同时运行一样。这个并行的错觉是由于上下文在高速的切换（每秒几十上百次）。当某一进程自愿放弃它的 CPU 时间或者系统分配的时间片用完时，就会发生上下文切换。
上下文切换有时也因硬件中断而触发。硬件中断是指硬件设备（如键盘、鼠标、调试解调器、系统时钟）给内核发送的一个信号，该信号表示一个事件（如按键、鼠标移动、从网络连接接收到数据）发生了。

9、A process undergoes a context switch every time it enters kernel mode from user mode.

正确答案： ×

当系统调用发生时 CPU 切换到内核态，这应该叫做模式切换而不是上下文切换，因为没有改变当前的进程。

10、A C program cannot directly invoke the OS system calls and must always use the C library for this purpose.

正确答案： ×

进程调度策略和内存虚拟化机制

1.假设一个简单的分段系统支持两个段：一个用于代码和堆（正增长），一个用于堆栈（负增长）。虚拟地址空间大小是128个字节。物理内存大小是512个字节。段寄存器的信息：段0的基址（正向增长）：0，界限：20（十进制）。段1的基址（负向增长）：0x200（十进制512），界限：20（十进制）。下面哪些是有效的虚拟内存访问？

A、0x1d (十进制: 29)

B、0x17b (十进制: 123)

C、0x10 (十进制: 16)

D、0x5a (十进制: 90)

E、0x0a (十进制: 10)

正确答案： BCE

2.下面关于多层反馈队列（MLFQ）调度的描述，哪些是可能的（正确的）？

A、MLFQ了解有关运行作业的一些信息

B、MLFQ会使长期运行的作业挨饿

C、MLFQ为作业们使用了不同长度的时间片

D、MLFQ使用了轮转（round robin）

E、MLFQ有时候会忘记它已经了解到的有关作业的信息

正确答案： ACDE

3.对于下面的作业，使用FIFO调度器，并且只有一个CPU。每个作业有一个“需要的”运行时间，即完成作业需要多少个CPU时间单元。作业A在时刻0到达，需要X个时间单元，作业B在时刻5到达，需要Y个时间单元，作业C在时刻10到达，需要Z个时间单元。假设平均周转时间在10到20（包含）之间，下面A、B和C的运行时间，哪些是可能的？

A、A=10, B=10, C=10

B、A=20, B=20, C=20

C、A=5, B=10, C=15

D、A=20, B=30, C=40

E、A=30, B=1, C=1

正确答案： AC

4.对于虚拟化内存来说，最简单的技术是动态重定位，或者“基址-界限”，假设有以下的系统特征：一个1KB的地址空间，基址寄存器被设为10000，界限寄存器被设为100。下面哪些物理内存的位置能够被运行程序合法地访问？

A、0

B、1000

C、10000

D、10050

E、10100

正确答案： CD

memory virtualization

1.Consider a system with a 6 bit virtual address space, and 16 byte pages/frames. The mapping from virtual page numbers to physical frame numbers of a process is (0,8), (1,3), (2,11), and (3,1). Translate the following virtual addresses to physical addresses. Note that all addresses are in decimal. Write your answer in decimal.
(a) 20
(b) 40

正确答案：
第一空： 52
第二空： 184
答案解析：
(a) 20 = 01 0100 = 11 0100 = 52

(b) 40 = 10 1000 = 1011 1000 = 184

页面内作为偏移量所需的位数：log2(16)= 4位用于偏移；
在虚拟地址的6位中，4位用于偏移，这意味着每个进程都有2^2 = 4虚拟页面；
由(1,3)，知01对应11；
由(2,11)，知10对应1011；

2.Consider a simple system running a single process. The size of physical frames and logical pages is 16 bytes. The RAM can hold 3 physical frames. The virtual addresses of the process are 6 bits in size. The program generates the following 20 virtual address references as it runs on the CPU: 0, 1, 20, 2, 20, 21, 32, 31, 0, 60, 0, 0, 16, 1, 17, 18, 32, 31, 0, 61. (Note: the 6-bit addresses are shown in decimal here.) Assume that the physical frames in RAM are initially empty and do not map to any logical page.

(a) Translate the virtual addresses above to logical page numbers referenced by the process.
That is, write down the reference string of 20 page numbers corresponding to the virtual address accesses above. Assume pages are numbered starting from 0, 1, …
answer example: 0, 1, 1, 0, 1, 2, 3, 2, 1, 2, 0, 1, 1, 0, 1, 2, 3, 2, 1, 2

(b) Calculate the number of page faults genrated by the accesses above, assuming a FIFO page replacement algorithm.

(d) What would be the lowest number of page faults achievable in this example, assuming an optimal page replacement algorithm were to be used?

正确答案：

第一空： 0, 0, 1, 0, 1, 1, 2, 1, 0, 3, 0, 0, 1, 0, 1, 1, 2, 1, 0, 3
第二空： 8
第三空： 6
第四空： 6
答案解析：
(a) For 6 bit virtual addresses, and 4 bit page offsets (page size 16 bytes), the most signiﬁcant 2 bits of a virtual address will represent the page number. So the reference string is 0, 0, 1, 0, 1, 1, 2, 1, 0, 3 (repeated again).

2 (b) Page faults with FIFO = 8. Page faults on 0,1,2,3 (replaced 0), 0 (replaced 1), 1 (replaced 2), 2 (replaced 3), 3.© Page faults with LRU = 6. Page faults on 0, 1, 2, 3 (replaced 2), 2 (replaced 3), 3.

(d) The optimum algorithm will replace the page least likely to be used in future, and would look like LRU above.

3.Consider an operating system that uses 48-bit virtual addresses and 16KB pages. The system uses a hierarchical page table design to store all the page table entries of a process, and each page table entry is 4 bytes in size. What is the total number of pages that are required to store the page table entries of a process, across all levels of the hierarchical page table?

Please use 2^10 to imply power, for example,2 to the power of 10 is 2^10

Answer example: 2²⁰⁺²20+2
正确答案：

第一空： 2²²⁺²10+1
答案解析：

Page size = 2^14bytes. So, the number of page table entries = 2^48/2 14= 2^34. Each page can store 16KB/4 = 2^12 page table entries. So, the number of innermost pages = 2^34 / 2^12 = 2^22 .

Now, pointers to all these innermost pages must be stored in the next level of the page table, so the next level of the page table has 2^22 / 2^12 = 2^10 pages. Finally, a single page can store all the 2^10 page table entries, so the outermost level has one page.

So, the total number of pages that store page table entries is 2^22 + 2^10 + 1.

二.判断题（共5题,30.0分）

TLB是现代分页系统中的一个关键部分。假设有下面的系统：页大小是64个字节，TLB包含了4项，TLB替换策略是LRU（最近最少使用）。下面的每一个代表了一个虚拟内存地址轨迹，即，一个程序引用的一系列虚拟内存地址。在下面的轨迹中，可能通过TLB加速执行的打“√”，不能加速的打“×”。

0, 100, 200, 1, 101, 201, … (repeats in this pattern)

（6.0分）
我的答案：√
2.
3.TLB是现代分页系统中的一个关键部分。假设有下面的系统：页大小是64个字节，TLB包含了4项，TLB替换策略是LRU（最近最少使用）。下面的每一个代表了一个虚拟内存地址轨迹，即，一个程序引用的一系列虚拟内存地址。在下面的轨迹中，可能通过TLB加速执行的打“√”，不能加速的打“×”。

0, 100, 200, 300, 0, 100, 200, 300, … (repeats)
正确答案：√

4.TLB是现代分页系统中的一个关键部分。假设有下面的系统：页大小是64个字节，TLB包含了4项，TLB替换策略是LRU（最近最少使用）。下面的每一个代表了一个虚拟内存地址轨迹，即，一个程序引用的一系列虚拟内存地址。在下面的轨迹中，可能通过TLB加速执行的打“√”，不能加速的打“×”。

0, 1000, 2000, 3000, 4000, 0, 1000, 2000, 3000, 4000, … (repeats)
正确答案：×

5.TLB是现代分页系统中的一个关键部分。假设有下面的系统：页大小是64个字节，TLB包含了4项，TLB替换策略是LRU（最近最少使用）。下面的每一个代表了一个虚拟内存地址轨迹，即，一个程序引用的一系列虚拟内存地址。在下面的轨迹中，可能通过TLB加速执行的打“√”，不能加速的打“×”。

0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, … (repeats)
正确答案：√

6.TLB是现代分页系统中的一个关键部分。假设有下面的系统：页大小是64个字节，TLB包含了4项，TLB替换策略是LRU（最近最少使用）。下面的每一个代表了一个虚拟内存地址轨迹，即，一个程序引用的一系列虚拟内存地址。在下面的轨迹中，可能通过TLB加速执行的打“√”，不能加速的打“×”。

300, 200, 100, 0, 300, 200, 100, 0, … (repeats)
正确答案：√

并发

1下面是一个并发程序（多线程的），pthread create() 和pthread join()运行正确，不返回错误。

该程序的可能输出是什么？

A、0

B、1000

C、999

D、998

E、1002

正确答案： CD

2Assume the following list insertion code, which inserts into a list pointed to by shared global variable head:
int List_Insert(int key) {
node_t * n = malloc(sizeof(node_t));
if (n == NULL) { return -1; }
n->key = key;
n->next = head;
head = n;
return 0;
}

This code is executed by each of three threads exactly once, without adding any synchronization primitives (such as locks). Assuming malloc() is thread-safe (i.e., can be called without worries of data races) and that malloc() returns successfully, how long might the list be when these three threads are ﬁnished executing? (assume the list was empty to begin)

A、0

B、1

C、2

D、3

E、4

正确答案： BCD
答案解析：

Assumes list empty at beginning. Because there is a race to include a node into the list, it is possible that a node gets dropped during insert. If we have three threads doing an insert, they call could succeed (they get serialized for some reason), or only one could succeed (with the other two updates lost). In no case can all get lost.
译：假设列表开头是空的。因为争相将节点包括在列表中，所以在插入过程中可能会删除节点。如果我们有三个线程进行插入，则它们调用可能会成功（由于某种原因而被序列化），或者只有一个可能成功（其他两个更新丢失）。在任何情况下都不会迷路。

3 Here is some more multi-threaded code:
void * printer(void * arg) {
char * p = (char * ) arg;
printf("%c", * p);
return NULL;
}
int main(int argc, char * argv[]) {
pthread_t p[5];
for (int i = 0; i < 5; i++) {
char * c = malloc(sizeof(char)); * c = ’a’ + i; // hint: ’a’ + 1 = ’b’, etc.
pthread_create(&p[i], NULL, printer, (void * ) c);
}
for (int i = 0; i < 5; i++)
pthread_join(p[i], NULL);
return 0;
}
A、abcde

B、edcba

C、cccde

D、eeeee

E、aaaaa

正确答案： AB
答案解析：

Each thread is created, and handed a unique argument with a letter in it: ’a’, or ’b’, or ’c’, or ’d’, or ’e’. The thread may run in any order, thus any output with one letter each, but in arbitrary order,is possible.
每个线程都会被创建，并传递一个带有字母的唯一参数：“ a”，“ b”，“ c”，“ d”或“e”。线程可以以任何顺序运行，因此任何输出，每个输出只有一个字母，但是可以以任意顺序运行。

4.One way to avoid deadlock is to schedule threads carefully. Assume the following characteristics of threads T1, T2, and T3:
T1 (at some point) acquires and releases locks L1, L2
T2 (at some point) acquires and releases locks L1, L3
T3 (at some point) acquires and releases locks L3, L1, and L4
For which schedules below is deadlock possible?

A、T1 runs to completion, then T2 to completion, then T3 runs

B、T1 and T2 run concurrently to completion, then T3 runs

C、T1, T2, and T3 run concurrently

D、T3 runs to completion, then T1 and T2 run concurrently

E、T1 and T3 run concurrently to completion, then T2 runs

正确答案： C
答案解析：
The key to this problem: do threads that CAN deadlock ever run at the same time? If so, they might deadlock. If not, it isn’t. From the above, only T2 and T3 can deadlock, because they each grab two locks (L1 and L3) in some order.

5.Assume the following multi-threaded memory allocator, roughly sketched out as follows:
#define MAX_HEAP_SIZE 400
int bytes_left = MAX_HEAP_SIZE;
pthread_cond_t c;
pthread_mutex_t m;
void * allocate(int size) {
pthread_mutex_lock(&m);
while (bytes_left < size)
pthread_cond_wait(&c, &m);
void * ptr = …; // get mem from internal data structs
bytes_left -= size;
pthread_mutex_unlock(&m);
return ptr;
}
void free(void * ptr, int size) {
pthread_mutex_lock(&m);
bytes_left += size;
pthread_cond_signal(&c);
pthread_mutex_unlock(&m);
}
Assume all of memory is used up (i.e., bytes left is 0). Then:
One thread (T1) calls allocate(100)
Some time later, a second thread (T2) calls allocate(1000)
Finally, some time later, a third thread (T3) calls free(200)
Assuming all calls to thread library functions work as expected, which of the following are possible just after this sequence of events has taken place?

A、T1 and T2 remain blocked inside allocate()

B、T1 becomes unblocked, gets 100 bytes allocated, and returns from allocate()

C、T2 becomes unblocked, gets 1000 bytes allocated, and returns from allocate()

D、T3 becomes blocked inside free()

E、T1, T2, and T3 become deadlocked

正确答案： AB

答案解析：
The problem with this code example is that when free() signals a waiting thread, there is no guarantee it wakes “the right” thread, i.e., it may wake a thread that is waiting for too much memory. In this case, we have T1 waiting for 100 bytes, T2 waiting for 1000 bytes, and then T3 freeing only 200 bytes (not enough for T2 to succeed in allocation, but enough for T1). Thus:

A. Possible Possible, because the signal may wake T2, which then rechecks its condition, and goes back to sleep, potentially forever.
B. Possible If we’re luck (instead), T1 gets awoken by T3, and then succeeds in its allocation request.
C. Not Possible There aren’t 1000 bytes free, so this should not happen.
D. Not Possible Not possible (really) because there is nothing to get permanently blocked upon. That said, the lock() acquisition could take a little while …
E. Not Possible Only one lock here, so no deadlock can arise.

二.判断题（共10题,50.0分）
1.Is it necessary for threads in a process to have separate stacks?

正确答案：√

2.Is it necessary for threads in a process to have separate copies of the program executable?

正确答案：×

3.Can one have concurrent execution of threads/processes without having parallelism?

正确答案：√

4.Consider N threads in a process that share a global variable in the program. If one thread makes a change to the variable, this change visible to other threads.

正确答案：√

5.Consider N threads in a process. If one thread passes certain arguments to a function in the program, these arguments are visible to the other threads.

正确答案：×

6.A Semaphore is a useful synchronization primitive. Which of the following statements are true of semaphores?
Each semaphore has an integer value

正确答案：√
答案解析：
By deﬁnition, each semaphore has a value.

7.A Semaphore is a useful synchronization primitive. Which of the following statements are true of semaphores?
If a semaphore is initialized to 1, it can be used as a lock

正确答案：√
答案解析：
This is called a binary semaphore.

8.A single lock and condition variable can be used in tandem to implement a semaphore

正确答案：√
答案解析：
This is true, along with a state variable to track the value of the semaphore.

9.Calling sem post() may block, depending on the current value of the semaphore

正确答案：×
答案解析：
Only sem wait() blocks, sem post() just does its work and returns.

sem_post函数（函数原型 int sem_post(sem_t *sem);）作用是给信号量的值加上一个“1”。
当有线程阻塞在这个信号量上时，调用这个函数会使其中一个线程不在阻塞，选择机制是有线程的调度策略决定的。 sem_wait函数（函数原型
int sem_wait(sem_t * sem);）
它的作用是从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法。

10.Semaphores can be initialized to values higher than 1

正确答案：√
答案解析：
This is useful in some cases as described in the book.

Persistance持久化

1.Consider a ﬁle system with 512-byte blocks. Assume an inode of a ﬁle holds pointers to 2 direct data blocks, and a pointer to a single indirect block. Further, assume that the single indirect block can hold pointers to 4 other data blocks. What is the maximum ﬁle size that can be supported by such an inode design?

A、512

B、1024

C、3072

D、4096

正确答案： C

2.Consider a FAT ﬁle system where disk is divided into 512 byte blocks, and every FAT entry can store an 4 bit block number. What is the maximum size of a disk partition that can be managed by such a FAT design?

A、4096

B、8192

C、2048

D、512

正确答案： B
答案解析：
2^N∗ M

3.Consider a secondary storage system of size 2 TB, with 512-byte sized blocks. Assume that the ﬁlesystem uses a multilevel inode datastructure to track data blocks of a ﬁle. The inode has 64 bytes of space available to store pointers to data blocks, including a single indirect block, a double indirect block, and several direct blocks. What is the maximum ﬁle size that can be stored in such a ﬁle system?

A、16526

B、72704

C、8461312

D、9306112

正确答案： C
答案解析：
Number of data blocks = 2^41/29= 2 32, so 32 bits or 4 bytes are required to store the number of a data block.

Number of data block pointers in the inode = 64/4 = 16, of which 14 are direct blocks. The single indirect block stores pointers to 512/4 = 128 data blocks. The double indirect block points to 128 single indirect blocks, which in turn point to 128 data blocks each.

So, the total number of data blocks in a ﬁle can be 14 + 128 + 128128 = 16526, and the maximum ﬁle size is 16526512 bytes.

数据块的数量= 2 ^ 41/2 ^ 9 = 2 32，因此需要32位或4个字节来存储数据块的数量。
inode中数据块指针的数量= 64/4 = 16，其中14个是直接块。单个间接块存储指向512/4 =
128个数据块的指针。双间接块指向128个单个间接块，每个间接块依次指向128个数据块。
因此，一个文件中的数据块总数可以为14 + 128 + 128 * 128 = 16526，最大文件大小为16526 * 512字节。

二.判断题（共2题,40.0分）
1 Consider a ﬁle D1/F1 that is hard linked from another parent directory D2. Then the directory entry of this ﬁle (including the ﬁlename and inode number) in directory D1 must be exactly identical to the directory entry in directory D2.

正确答案：×
答案解析：
F (the ﬁle name can be different)

2.A soft link can create a link between ﬁles across different ﬁle systems, whereas a hard link can only create links between a directory and a ﬁle within the same ﬁle system.

正确答案：√
答案解析：
T (becasue hard link stores inode number, which is unique only within a ﬁle system)