精华内容
下载资源
问答
  • 现代操作系统第四版正文及课后答案打包下载,正文与课后答案都没有水印,正文 PDF 文件内有目录和标签。
  • @T现代操作系统第四版参考答案 现代操作系统英文第四版第二章参考答案——进程 先更新第二章的答案,习惯中文的童鞋请左转百度翻译 Solution for chapter 2 The transition from blocked to running is ...

    @T现代操作系统第四版参考答案

    现代操作系统英文第四版第二章参考答案——进程

    先更新第二章的答案,习惯中文的童鞋请左转百度翻译

    Solution for chapter 2

    1. The transition from blocked to running is conceivable. Suppose that a process is blocked on I/O and the I/O finishes. If the CPU is otherwise idle, the process could go directly from blocked to running. The other missing transition, from ready to blocked, is impossible. A ready process cannot do I/O or anything else that might block it. Only a running process can block.

    2. You could have a register containing a pointer to the current process-table entry. When I/O completed, the CPU would store the current machine state in the current process-table entry. Then it would go to the interrupt vector for the interrupting device and fetch a pointer to another process-table entry (the service procedure). This process would then be started up.

    3. Generally, high-level languages do not allow the kind of access to CPU hardware that is required. For instance, an interrupt handler may be required to enable and disable the interrupt servicing a particular device, or to manipulate data within a process’ stack area. Also, interrupt service routines must execute as rapidly as possible.

    4. There are several reasons for using a separate stack for the kernel. Two of them are as follows. First, you do not want the operating system to crash because a poorly written user program does not allow for enough stack space. Second, if the kernel leaves stack data in a user program’s memory space upon return from a system call, a malicious user might be able to use this data to find out information about other processes.

    5. The chance that all five processes are idle is 1/32, so the CPU idle time is 1/32.

    6. There is enough room for 14 processes in memory. If a process has an I/O of p, then the probability that they are all waiting for I/O is p14. By equating this to 0.01, we get the equation p14 = 0. 01. Solving this, we get p = 0. 72, so we can tolerate processes with up to 72% I/O wait.

    7. If each job has 50% I/O wait, then it will take 40 minutes to complete in the absence of competition. If run sequentially, the second one will finish 80 minutes after the first one starts. With two jobs, the approximate CPU utilization is 1 − 0. 52. Thus, each one gets 0.375 CPU minute per minute of real time. To accumulate 20 minutes of CPU time, a job must run for 20/0.375 minutes, or about 53.33 minutes. Thus running sequentially the jobs finish after 80 minutes, but running in parallel they finish after 53.33 minutes.

    8. The probability that all processes are waiting for I/O is 0.46 which is 0.004096. Therefore, CPU utilization = 1 − 0. 004096 = 0: 995904.

    9. The client process can create separate threads; each thread can fetch a different part of the file from one of the mirror servers. This can help reduce downtime. Of course, there is a single network link being shared by all threads. This link can become a bottleneck as the number of threads becomes very large.

    10. It would be difficult, if not impossible, to keep the file system consistent. Suppose that a client process sends a request to server process 1 to update a file. This process updates the cache entry in its memory. Shortly thereafter, another client process sends a request to server 2 to read that file. Unfortunately, if the file is also cached there, server 2, in its innocence, will return obsolete data. If the first process writes the file through to the disk after caching it, and server 2 checks the disk on every read to see if its cached copy is up-to-date, the system can be made to work, but it is precisely all these disk accesses that the caching system is trying to avoid.

    11. No. If a single-threaded process is blocked on the keyboard, it cannot fork.

    12. A worker thread will block when it has to read a Web page from the disk. If user-level threads are being used, this action will block the entire process, destroying the value of multithreading. Thus it is essential that kernel threads are used to permit some threads to block without affecting the others.

    13. Yes. If the server is entirely CPU bound, there is no need to have multiple threads. It just adds unnecessary complexity. As an example, consider a telephone directory assistance number (like 555-1212) for an area with 1 million people. If each (name, telephone number) record is, say, 64 characters, the entire database takes 64 megabytes and can easily be kept in the server’s memory to provide fast lookup.

    14. When a thread is stopped, it has values in the registers. They must be saved, just as when the process is stopped. the registers must be saved. Multiprogramming threads is no different than multiprogramming processes, so each thread needs its own register save area.

    15. Threads in a process cooperate. They are not hostile to one another. If yielding is needed for the good of the application, then a thread will yield. After all, it is usually the same programmer who writes the code for all of them.

    16. User-level threads cannot be preempted by the clock unless the whole process’ quantum has been used up (although transparent clock interrupts can happen). Kernel-level threads can be preempted individually. In the latter case, if a thread runs too long, the clock will interrupt the current process and thus the current thread. The kernel is free to pick a different thread from the same process to run next if it so desires.

    17. In the single-threaded case, the cache hits take 12 msec and cache misses take 87 msec. The weighted average is 2/3 × 12 + 1/3 × 87. Thus, the mean request takes 37 msec and the server can do about 27 per second. For a multithreaded server, all the waiting for the disk is overlapped, so every request takes 12 msec, and the server can handle 83 1/3 requests per second.

    18. The biggest advantage is the efficiency. No traps to the kernel are needed to switch threads. The biggest disadvantage is that if one thread blocks, the entire process blocks.

    19. Yes, it can be done. After each call to pthread create, the main program could do a pthread join to wait until the thread just created has exited before creating the next thread.

    20. The pointers are really necessary because the size of the global variable is unknown. It could be anything from a character to an array of floating-point numbers. If the value were stored, one would have to giv e the size to create global, which is all right, but what type should the second parameter of set global be, and what type should the value of read global be?

    21. It could happen that the runtime system is precisely at the point of blocking or unblocking a thread, and is busy manipulating the scheduling queues. This would be a very inopportune moment for the clock interrupt handler to begin inspecting those queues to see if it was time to do thread switching, since they might be in an inconsistent state. One solution is to set a flag when the runtime system is entered. The clock handler would see this and set its own flag, then return. When the runtime system finished, it would check the clock flag, see that a clock interrupt occurred, and now run the clock handler.

    22. Yes it is possible, but inefficient. A thread wanting to do a system call first sets an alarm timer, then does the call. If the call blocks, the timer returns control to the threads package. Of course, most of the time the call will not block, and the timer has to be cleared. Thus each system call that might block has to be executed as three system calls. If timers go off prematurely, all kinds of problems develop. This is not an attractive way to build a threads package.

    23. Yes, it still works, but it still is busy waiting, of course.

    24. It certainly works with preemptive scheduling. In fact, it was designed for that case. When scheduling is nonpreemptive, it might fail. Consider the case in which turn is initially 0 but process 1 runs first. It will just loop forever and never release the CPU.

    25. The priority inversion problem occurs when a low-priority process is in its critical region and suddenly a high-priority process becomes ready and is scheduled. If it uses busy waiting, it will run forever. With user-level threads, it cannot happen that a low-priority thread is suddenly preempted to allow a high-priority thread run. There is no preemption. With kernel-level threads this problem can arise.

    26. With round-robin scheduling it works. Sooner or later L will run, and eventually it will leave its critical region. The point is, with priority scheduling, L never gets to run at all; with round robin, it gets a normal time slice periodically, so it has the chance to leave its critical region.

    27. Each thread calls procedures on its own, so it must have its own stack for the local variables, return addresses, and so on. This is equally true for user-level threads as for kernel-level threads.

    28. Yes. The simulated computer could be multiprogrammed. For example, while process A is running, it reads out some shared variable. Then a simulated clock tick happens and process B runs. It also reads out the same variable. Then it adds 1 to the variable. When process A runs, if it also adds 1 to the variable, we have a race condition.

    29. Yes, it will work as is. At a given time instant, only one producer (consumer) can add (remove) an item to (from) the buffer.

    30. The solution satisfies mutual exclusion since it is not possible for both processes to be in their critical section. That is, when turn is 0, P0 can execute its critical section, but not P1. Likewise, when turn is 1. However, this assumes P0 must run first. If P1 produces something and it puts it in a buffer, then while P0 can get into its critical section, it will find the buffer empty and block. Also, this solution requires strict alternation of the two processes, which is undesirable.

    31. To do a semaphore operation, the operating system first disables interrupts. Then it reads the value of the semaphore. If it is doing a down and the semaphore is equal to zero, it puts the calling process on a list of blocked processes associated with the semaphore. If it is doing an up, it must check to see if any processes are blocked on the semaphore. If one or more processes are blocked, one of them is removed from the list of blocked processes and made runnable. When all these operations have been completed, interrupts can be enabled again.

    32. Associated with each counting semaphore are two binary semaphores, M, used for mutual exclusion, and B, used for blocking. Also associated with each counting semaphore is a counter that holds the number of ups minus the number of downs, and a list of processes blocked on that semaphore. To implement down, a process first gains exclusive access to the semaphores, counter, and list by doing a down on M. It then decrements the counter. If it is zero or more, it just does an up on M and exits. If M is negative, the process is put on the list of blocked processes. Then an up is done on M and a down is done on B to block the process. To implement up, first M is downed to get mutual exclusion, and then the counter is incremented. If it is more than zero, no one was blocked, so all that needs to be done is to up M. If, however, the counter is now neg ative or zero, some process must be removed from the list. Finally, an up is done on B and M in that order.

    33. If the program operates in phases and neither process may enter the next phase until both are finished with the current phase, it makes perfect sense to use a barrier.

    34. With kernel threads, a thread can block on a semaphore and the kernel can run some other thread in the same process. Consequently, there is no problem using semaphores. With user-level threads, when one thread blocks on a semaphore, the kernel thinks the entire process is blocked and does not run it ever again. Consequently, the process fails.

    35. It is very expensive to implement. Each time any variable that appears in a predicate on which some process is waiting changes, the run-time system must re-evaluate the predicate to see if the process can be unblocked. With the Hoare and Brinch Hansen monitors, processes can only be awakened on a signal primitive.

    36. The employees communicate by passing messages: orders, food, and bags in this case. In UNIX terms, the four processes are connected by pipes.

    37. It does not lead to race conditions (nothing is ever lost), but it is effectively busy waiting.

    38. It will take nT sec.

    39. Three processes are created. After the initial process forks, there are two processes running, a parent and a child. Each of them then forks, creating two additional processes. Then all the processes exit.

    40. If a process occurs multiple times in the list, it will get multiple quanta per cycle. This approach could be used to give more important processes a larger share of the CPU. But when the process blocks, all entries had better be removed from the list of runnable processes.

    41. In simple cases it may be possible to see if I/O will be limiting by looking at source code. For instance a program that reads all its input files into buffers at the start will probably not be I/O bound, but a problem that reads and writes incrementally to a number of different files (such as a compiler) is likely to be I/O bound. If the operating system provides a facility such as the UNIX ps command that can tell you the amount of CPU time used by a program, you can compare this with the total time to complete execution of the program. This is, of course, most meaningful on a system where you are the only user.

    42. If the context switching time is large, then the time quantum value has to be proportionally large. Otherwise, the overhead of context switching can be quite high. Choosing large time quantum values can lead to an inefficient system if the typical CPU burst times are less than the time quantum. If context switching is very small or negligible, then the time quantum value can be chosen with more freedom.

    43. The CPU efficiency is the useful CPU time divided by the total CPU time. When Q ≥ T, the basic cycle is for the process to run for T and undergo a process switch for S. Thus, (a) and (b) have an efficiency of T/(S + T). When the quantum is shorter than T, each run of T will require T/Q process switches, wasting a time ST/Q. The efficiency here is then T /(T + ST/Q) which reduces to Q/(Q + S), which is the answer to ©. For (d), we just substitute Q for S and find that the efficiency is 50%. Finally, for (e), as Q → 0 the efficiency goes to 0.

    44. Shortest job first is the way to minimize average response time. 0<X ≤ 3: X, 3, 5, 6, 9. 3<X ≤ 5: 3, X, 5, 6, 9. 5<X ≤ 6: 3, 5, X, 6, 9. 6<X ≤ 9: 3, 5, 6, X, 9. X > 9: 3, 5, 6, 9,X.

    45. For round robin, during the first 10 minutes each job gets 1/5 of the CPU. At the end of 10 minutes, C finishes. During the next 8 minutes, each job gets 1/4 of the CPU, after which time D finishes. Then each of the three remaining jobs gets 1/3 of the CPU for 6 minutes, until B finishes, and so on. The finishing times for the five jobs are 10, 18, 24, 28, and 30, for an average of 22 minutes. For priority scheduling, B is run first. After 6 minutes it is finished. The other jobs finish at 14, 24, 26, and 30, for an average of 18.8 minutes. If the jobs run in the order A through E, they finish at 10, 16, 18, 22, and 30, for an average of 19.2 minutes. Finally, shortest job first yields finishing times of 2, 6, 12, 20, and 30, for an average of 14 minutes.

    46. The first time it gets 1 quantum. On succeeding runs it gets 2, 4, 8, and 15, so it must be swapped in 5 times.

    47. Each voice call needs 200 samples of 1 msec or 200 msec. Together they use 400 msec of CPU time. The video needs 11 msec 33 1/3 times a second for a total of about 367 msec. The sum is 767 msec per second of real time so the system is schedulable.

    48. Another video stream consumes 367 msec of time per second for a total of 1134 msec per second of real time so the system is not schedulable.

    49. The sequence of predictions is 40, 30, 35, and now 25.

    50. The fraction of the CPU used is 35/50 + 20/100 + 10/200 + x/250. To be schedulable, this must be less than 1. Thus x must be less than 12.5 msec.

    51. Yes. There will be always at least one fork free and at least one philosopher that can obtain both forks simultaneously. Hence, there will be no deadlock. You can try this for N = 2, N = 3 and N = 4 and then generalize.

    52. Each voice call runs 166.67 times/second and uses up 1 msec per burst, so each voice call needs 166.67 msec per second or 333.33 msec for the two of them. The video runs 25 times a second and uses up 20 msec each time, for a total of 500 msec per second. Together they consume 833.33 msec per second, so there is time left over and the system is schedulable.

    53. The kernel could schedule processes by any means it wishes, but within each process it runs threads strictly in priority order. By letting the user process set the priority of its own threads, the user controls the policy but the kernel handles the mechanism.

    54. If a philosopher blocks, neighbors can later see that she is hungry by checking his state, in test, so he can be awakened when the forks are available.

    55. The change would mean that after a philosopher stopped eating, neither of his neighbors could be chosen next. In fact, they would never be chosen. Suppose that philosopher 2 finished eating. He would run test for philosophers 1 and 3, and neither would be started, even though both were hungry and both forks were available. Similarly, if philosopher 4 finished eating, philosopher 3 would not be started. Nothing would start him.

    56. Variation 1: readers have priority. No writer may start when a reader is active. When a new reader appears, it may start immediately unless a writer is currently active. When a writer finishes, if readers are waiting, they are all started, regardless of the presence of waiting writers. Variation 2: Writers have priority. No reader may start when a writer is waiting. When the last active process finishes, a writer is started, if there is one; otherwise, all the readers (if any) are started. Variation 3: symmetric version. When a reader is active, new readers may start immediately. When a writer finishes, a new writer has priority, if one is waiting. In other words, once we have started reading, we keep reading until there are no readers left. Similarly, once we have started writing, all pending writers are allowed to run.

    57. A possible shell script might be
      if[!-f numbers ]; then echo 0 > numbers; fi
      count = 0;
      while (test $count !=200)
      do
      count = ‘expr 4count + 1’
      n=‘tail -1 numbers’
      expr $n +1 >>number
      done
      Run the script twice simultaneously, by starting it once in the background (using &) and again in the foreground. Then examine the file numbers. It will probably start out looking like an orderly list of numbers, but at some point it will lose its orderliness, due to the race condition created by running two copies of the script. The race can be avoided by having each copy of the script test for and set a lock on the file before entering the critical area, and unlocking it upon leaving the critical area. This can be done like this:

      if In numbers numbers.lock
      then 
      	n='tail -1 numbers'
      	expr $n +1 >>numbers 
      	rm numbers.lock
      fi
      

    This version will just skip a turn when the file is inaccessible. Variant solutions could put the process to sleep, do busy waiting, or count only loops in which the operation is successful.

    56以后属于开放性题目,留给读者练习发挥的空间。

    展开全文
  • 1: 进程在阻塞之后不能直接运行,要先转为就绪态再由3转为运行。 就绪不能直接阻塞,因为就绪的进程并为运行,不会阻塞。 2: 应该有一个寄存器存储当前进程表项的指针,当I/O结束时,CPU把当前的机器...防止操作...

    1:
    进程在阻塞之后不能直接运行,要先转为就绪态再由3转为运行。
    就绪不能直接阻塞,因为就绪的进程并未运行,不会阻塞。

    2:
    应该有一个寄存器存储当前进程表项的指针,当I/O结束时,CPU把当前的机器状态存入当前的进程表项中,然后转到中断向量读取另一个过程表项的指针,启动这个进程。

    3:
    高级语言不能直接访问CPU硬件,但必须进行这种访问,而且使用汇编编写减少了对线程/程序的影响。

    4:
    防止操作系统崩溃, 因为有些用户程序不支持足够的堆栈空间, 防止恶意的用户程序挖掘其他进程的信息。

    5:
    0.55

    6:
    最多可以容纳(4 * 1024 – 512)/ 256 = 14个进程, 设每个进程的等待I/O的时间与总运行时间的比例为p, 1 – p14 > 99%, 所以p < 71.9%。

    7:
    每个作业总的运行时间为40分钟, 若为顺序执行,最后一个作业需要40+40 = 80分钟完成;
    若为并行执行, cpu的利用率 = 1 – 0.5² = 0.75, 40 / 0.75 = 53.33分钟。

    8:
    1 – 0.46

    9:
    客户机进程创建多个线程, 每个线程从一个镜像服务器获取文件的不同部分。有助于减少停机时间

    10:
    难以保证文件系统的一致性。 若某客户进程给服务器进程1发送请求要更新文件, 然后另一个客户进程给服务器进程2发送请求要读数据,可能会读到更新前的数据。
    若给每个进程都分配cache会导致资源浪费, 因为不是所有的进程都要频繁的读写数据。

    11:
    不会, 如果单线程进程发生阻塞, 就不能创建子进程。

    12:
    应适应内核级线程。
    若使用用户级线程的话, 使用了阻塞的read调用,若被阻塞,整个进程中所有线程都会被阻塞, 因为用户级线程中内核不知道有线程的存在。

    13:
    多线程服务器, 分派线程去调用阻塞的工作线程。 工作线程去检查有关请求是否在web页面高速缓存中,如果没有, 该线程开始一个从磁盘调入页面的read操作, 并阻塞到该磁盘操作完成, 当工作线程阻塞时, 分派线程可以挑选另一个线程运行。 从而减少cpu空转的时间。
    若cpu和服务器完全绑定, 则不需要多线程, 单线程可以简单化。

    14:
    当进行线程切换时, 必须要保存线程的寄存器,多线程跟多进程没有什么不同。

    15:
    进程中的线程要合作,不能一个线程一直运行。

    16:
    用户级线程不可以被时钟中断, 而内核级线程可以, 若线程运行过久,时钟会切断当前进程。

    17:
    单线程的情况下, cache命中需要12ms, cache未命中需要87秒,加权平均为 1/3 * 87 + 2/3 * 12 = 37ms,1s / 37ms = 27。
    多线程的情况下,所有磁盘等待都是重叠的, 1s / 12ms = 83.3.

    18:
    用户级线程中,
    优点: 保存该线程状态的过程和调度程序都是本地过程, 效率比内核级线程高很多, 线程切换时不需要陷入内核, 也不需要对cache刷新, 并且允许线程有自己定制的调度算法。
    缺点: 在一个线程运行时, 在该进程中其他线程就不能运行, 除非该线程自动放弃cpu, 否则将一直运行下去。因为在一个进程内部, 没有时钟中断

    19:
    在创建线程后, 调用pthread_join等到刚刚创建的线程推出后再创建下一个线程。

    20:
    因为全局变量的类型位置, 要保存的话, 必须要传递给cread_globe。

    21:
    可能会出现不一致状态, 使用信号量。

    22:
    可能, 但效率很低, 线程请求一个系统调用, 需要先设定报警定时器,这种方法不好。

    23:
    有效。

    24:
    Peterson算法就是为抢占式调度而设计的。 而非抢占式调度可能会失败。

    25:
    优先级反转是指, 当低优先级进程进入临界区时,高优先级进程转为就绪态,但因为后者优先级高, 所以不会调度比他优先级低的进程,进而低优先级的进程无法离开临界区。
    而用户级线程不可能存在这个问题, 因为用户级线程不能中断, 内核级线程会出现这个问题。

    26:
    轮转调度算法不会出现这样的问题, 因为给每个进程分配时间片, 时间到了之后系统剥夺其cpu使用权, 所以死循环。

    27:
    每个线程都是自己调用过程, 它必须有一个栈来保存局部变量, 返回地址等。
    这一点用户级线程和内核级线程一样。

    28:
    竞争条件是指 多个进程或线程读写一个共享数据时, 其最终运行结果依赖于执行的相对时间。
    会, 模拟计算机也是多道程序设计。

    29:
    仍然可行, 因为在某一个时刻, 只有一个生产者/消费者可以访问共享缓冲区。

    30:
    当p1先运行的时候就会出问题。

    31:
    执行信号操作, 操作系统必须禁用中断, 然后它读取信号量的值,
    若执行P操作, 信号量的值小于0的话, 该进程进去排队队列中,若大于0, 则该进程继续执行。
    若为V操作, 信号量的值小于0的话, 释放等待队列中的一个进程, 若大于0, 则该进程继续执行。

    32:
    需要一个二元信号量M表示互斥, 一个二元信号量表示阻塞, 一个链表表示当前阻塞的进程, 一个counter表示执行v操作减去p执行p操作的数目。
    P操作: 首先对M进行P操作, 然后对counter进行P操作, 判断counter的值,若大于等于0, 则对M进行V操作, 若小于0, 把该进程记录在链表上再执行V操作, 并对B进行P操作从而阻塞该进程。
    V操作: 首先对M进行P操作, counter执行V操作, 若counter大于等于0, 则对M直接V操作, 若小于0, 从链表中选出一个进程, 然后对B、M依次执行V操作。
    33:
    只要两个进程不是生产者-消费者问题,就可以使用屏障。

    34:
    若在内核级线程中, 可以使用信号量, 该线程在信号量上阻塞, 而内核可以运行该进程中的其他线程, 可以实现同步。
    若在用户级线程中, 若该线程在信号量上阻塞, 整个进程就会被阻塞, 所以无法实现同步。

    35:
    这样做代价很高, 而用用他们两个的方法 只需要执行signal原语就可以唤醒进程。

    36:
    消息传递。
    食物, 订单, 袋子是消息。

    37:
    不会, 只会发生忙等待。

    38:
    nT

    39:
    3个

    40:
    可以让更重要的进程出现多次去获得更大的cpu使用时间, 若该进程阻塞时,能将该就绪进程列表中把当前进程包括当前进程的备份阻塞, 就允许出现多次。

    41:
    简单的情况下可以看出, 若程序开始时,读取所有输入文件, 则不是I/O密集型, 若经常对不同的文件进行读取, 则可能是I/O密集型。
    可以使用UNIX的ps操作, 获得程序运行的cpu时间, 与整个时间运行对比。

    42:
    若时间片非常短, 进行上下文切换所占的时间片比例就大。
    若时间片长, 上下文切换所占的时间比例就小。

    43:
    T / (T+S),
    T / (T+S),
    Q / (Q+S),
    1/ 2,
    ~0.

    44:
    采用最短作业优先调度(SJF), 判断X的取值范围。

    45:

    轮转调度:

    第一次分配10分钟cpu时间, 每个进程分配1/5的cpu时间, 第一次分配结束时, C进程结束。
    第二次分配8分钟cpu时间, 每个进程分配1/4的cpu时间, 第二次分配结束时, D进程结束。
    …………
    A进程需要30分钟, B进程需要24分钟, C进程需要10分钟, D进程需要18分钟, E进程需要28分钟。 平均22分钟。

    优先级调度:

    按优先级运行, 进程依次的执行时间为 6, 14, 24, 26, 30. 平均20分钟

    先来先服务

    进程依次执行时间为10, 16, 18, 22, 30, 平均19.2分钟

    最短作业优先

    进程依次执行时间为2, 6, 12, 20, 30, 平均14分钟。

    46:
    最高优先级的运行1个时间片, 次优先级运行2个时间片……
    运行之后进程优先级降低一级,
    所以需要5次, 1、2、4、8、15.

    47:
    1 / 5 * 2 + 11 / 33 = 11 / 15 < 1
    可以调度。

    48:
    1 / 5 * 2 + 11 / 33 * 2 > 1
    不可以调度。

    49:
    [(40 * 1 / 2 + 20 * 1 / 2) * 1 / 2 + 40 * 1 / 2] * 1 / 2 + 15 * 1 / 2 = 25ms.

    50:
    35 / 50 + 20 / 100 + 10 / 200 + 2 / 250 < 1
    x <= 12.5ms

    51:
    可以。

    52:
    1 / 6 * 2 + 20 / 1000 * 25 < 1, 可调度。

    53:
    内核通过任何方式调度进程, 进程严格按照优先级顺序执行。

    54:
    设置为HUNGRY之后, 在一个哲学家吃完之后, 就可以检查左右侧的哲学家是否为HUNGRY, 若此时他为HUNGRY并且他的左右叉子可用, 就可以设置为EATING。

    55:
    若这样改, 整个哲学家左右的哲学家永远是HUNGRY。

    56:
    读者优先: 只要有读者在读, 就不允许写者执行写操作, 当写者完成时, 全部读者进行读操作。
    写者优先:只要有写者再写, 就不允许读者进行读操作,每当结束一个进程时, 若有若有写者存在, 就启动写者, 否则启动所有读者。
    公平:一旦有读者开始读操作, 后续所有读者优先, 一旦有写者在写操作, 后续所有写者优先。

    展开全文
  • Modern-Operating-Systems-answers:《现代操作系统第四版习题编程实验答案
  • 为加深概念的理解,本书还详细介绍了操作系统,包括两个传统的系统UNIX和MS-DOS;两个分布式系统Amoeba和Mach。此外还简要介绍了NFS、AFS、ISIS等其他几个系统。 本书体系完整、内容丰富、叙述清晰,是大学...
  • 多数是根据英文原版答案翻译过来,少部分加了个人的理解 1、操作系统的两大主要作用是什么? 1.为应用程序提供一个资源集的清晰抽象(另一种说法:操作系统给用户提供了一个可扩展的机器。个人理解是...

    如有错误答案,请各位评论指出,多谢多谢

    1、操作系统的两大主要作用是什么?

    答:为应用程序提供一个资源集的清晰抽象(另一种说法:操作系统给用户提供了一个可扩展的机器。个人理解是通过对底层的抽象,对外提供各种接口支持扩展); 2.管理各种软硬件资源。

    2、在1.4节中描述了9中不同类型的操作系统,列举每种操作系统的应用(每种系统一种应用)

    • 1.大型操作系统(Mainframe operating system):大型保险公司的索赔流程处理系统

    • 2.服务器操作系统(Server operating system):比如苹果手机 的Siri所提供的语音到文本的转换服务

    • 3.多处理器操作系统(Multiprocessor operating system):视频编辑与渲染

    • 4.个人计算机操作系统(Personal computer operating system):文字处理应用

    • 5.掌上计算机操作系统(Handheld computer operating system):上下文感知推荐系统

    • 6.嵌入式操作系统(Embedded operating system):为DVD录像机设计的录像程序。

    • 7.传感器节点操作系统(Sensor-node operating system):野外温度监测

    • 8.实时操作系统(Real-time operating system):航空管制系统

    • 9.智能卡操作系统(Smart-card operating system):电子支付

    3.分时系统和多道程序系统的区别是什么?

    答:在分时系统中,多个用户可以使用他们自己的终端同时访问和执行计算系统上的计算。 多道程序设计系统允许用户同时运行多个程序。 所有分时系统都是多道程序设计系统,但并非所有多道程序设计系统都是分时系统,因为多道程序设计系统可以在只有一个用户的PC上运行。

    4.为了使用高速缓存,主存被划分为若干cache行,同城每行长32或64字节。每次缓存一整个cache行,每次缓存一整行而不是一个字节或一个字,这样的优点是什么?

    答:经验证据表明,存储器访问表现出引用局部原则,即如果读取某一个位置,则接下来访问这个位置的概率非常高,尤其是紧随其后的内存位置。 因此,通过缓存整个缓存行,接下来缓存命中的概率会增加。 此外,现代的硬件可以将32或64字节块整个传输到高速缓存行,比单个字节读取,总共读32或64字节的速度要快得多。

    5.在早期计算机中,每个字节的读写直接由CPU处理(即没有DMA)。对于多到程序而言这种组织方式有什么含义?

    答:DMA(Direc Memory Access):直接存储器访问。
    多道程序设计的主要原因是在某个程序等待I/O完成时,可以让CPU做一些其他操作。 如果没有DMA,则CPU完全占用I/O,因此通过多道程序设计没有任何收益增加获得(至少在CPU利用率方面)。 无论程序执行多少I/O,CPU都将100%处于忙碌。 这当然假设主要的延迟是数据被复制时的等待。 如果由于其他原因(例如,到达串行线路)I/O很慢,CPU可以执行其他工作。

    6.与访问I/O设备相关的指令通常是特权指令,也就是说,他们能在内核态执行而在用户态则不行,说明为什么这些指令是特权指令。

    答:典型的例子,比如对于I/O设备(例如,打印机)的访问,通常对不同用户限制也不同。某些用户可以允许打印任意数量的页面,某些用户可能根本不允许打印,而一些用户可能仅限于打印一定数量的页面。 这些限制由系统管理员根据某些策略设置。 需要强制执行此类策略,以便用户级别的程序不会干扰它们。

    7.系列计算机的思想在20世界60年代由IBM引入System/360大型机。现在这种思想是消亡还是存活?

    答:依然活着。 例如,英特尔使Core i3,i5和i7 CPU具有各种不同的属性,包括速度和功耗。 所有这些计算机都在架构上兼容。 只是它们的价格和性能不同。

    8.缓慢采用GUI的一个原因是支持他的硬件的成本高昂,为了支持25行80列的单色文本屏幕,需要多少视频RAM?对于1024x768像素24位色彩图需要多少RAM?在1980年每Kb 5美元,这些RAM成本是多少?现在成本多少?

    1. 25x80x1 = 2000字节
    2. 1024x768x3 = 2359296字节(一字节8位,24位就是三个字节)
    3. 成本自行计算

    9.在建立一个操作系统时有几个设计目的,例如资源利用、及时性、健壮性等,请列举两个可能相互矛盾的设计目的。

    考虑公平性和实时性。 公平性要求每个进程都以公平的方式分配其资源,没有任何进程获得超过公平份额。 另一方面,实时性需要根据不同进程必须完成执行的时间来分配资源。 实时进程可能会获得不成比例的资源份额。 他们就是互相矛盾的。

    10.内核态和用户态有哪些区别?解释在设计操作系统时存在两种不同的模式有什么帮助。

    大多数现代CPU提供两种执行模式:内核态和用户态。 CPU可以执行其指令集中的每条指令,并在内核态下执行时使用硬件的各种功能。 但是用户态只能执行部分指令,执行时仅使用部分功能。 拥有两种模式允许设计人员以用户态运行用户程序,从而拒绝他们访问关键指令。

    11.一个255GB大小的磁盘有65535个柱面,每个柱面255个扇区。每个扇区512字节。这个磁盘有多少盘片和磁头?假设平均寻道时间为11ms,平均旋转延迟为7ms,读取速度100MB/s,计算从一个扇区读取400kb需要的平均时间。

    磁头数= 255 GB /(65536 * 255 * 512)= 16
    盘片数量= 16/2 = 8
    读取操作完成的时间是寻道时间+旋转延迟+传输时间。 寻道时间为11 ms,旋转延迟为7 ms,传输时间为4 ms,因此平均传输时间为22 ms。

    12、下面哪一条指令只能在内核态使用?

    • a 禁止所有的中断
    • b 读日期-时间时钟
    • c 设置日期-时间时钟
    • d 改变存储器映像

    选择 a、c、d

    13、考虑一个有两个CPU的系统,且每一个CPU有两个线程(超线程)。假设有三个程序P0、P1\P2,分别以运行时间5ms, 10ms,20ms开始,运行这些程序需要多少时间?假设这三个程序都是100%限于CPU,在运行时无阻赛,并且一旦设定就不改变CPU。

    答: 完成这些程序的执行可能需要20,25或30毫秒,具体取决于操作系统如何安排它们。 如果P0和P1在同一个CPU上进行调度,而P2在另一个CPU上进行调度,则需要20毫秒。 如果P0和P2安排在同一个CPU上并且P1安排在另一个CPU上,则需要25毫秒。 如果P1和P2安排在同一个CPU上并且P0安排在另一个CPU上,则需要30毫秒。 如果所有三个都在同一个CPU上,则需要35毫秒。

    14、一台计算机有一个四级流水线,每一级都花费相同的时间执行其工作,即1ns, 这台机器每秒可执行多少条指令?

    答:每一纳秒的指令都从管道中出现。 这意味着机器每秒执行10亿条指令。 根本没关系管道有多少个阶段。 每级1 nsec的10级流水线每秒也会执行10亿条指令。 重要的是完成的指令弹出管道末端的频率。

    15.假设一个计算机系统有高速缓存、内存以及磁盘,操作系统用呼你内存。读取缓存中的一个词需要1ns, 内存需要10ns, 磁盘需要10ms。如果缓存命中率是95%, 内存的是99%(缓存失效时),读取一个词的平均时间是多少?

    答:平均访问时间=
    0.95×1 nsec(词在缓存中)
    + 0.05×0.99×10 nsec(词在RAM中,但不在缓存中)
    + 0.05×0.01×10,000,000 nsec(仅限磁盘上的词)
    = 5001.445纳秒
    =5.001445μsec
    

    16.在用户程序进行一个系统调用,以读写磁盘文件时,该程序提供指示说明了所需要的文件,一个指向数据缓冲区的指针以及计数。然后,控制权转给操作系统,它调用相关的驱动程序。假设驱动程序启动磁盘并且直到中断发生才终止。在从磁盘读的情况下,很明显,调用者会被阻塞(因为文件中没有数据)。在向磁盘写时会发生什么情况?需要把调用者阻塞一直等到磁盘传送完成为止吗?

    答:也许。如果调用者取回控制,并且在最终发生写操作时立即重写数据,将会写入错误的数据。然而,如果驱动程序在返回之前首先复制将数据复制到一个专用的缓冲器,那么调用者可以立即继续执行。另一个可能性是允许调用者继续,并且在缓冲器可以再用时给它一个信号,但是这需要很髙的技巧,而且容易出错。

    17.什么是陷阱指令?在操作系统中他的用途。

    陷阱指令将一个处理器的执行模式从用户模式切换到内核模式。该指令允许用户程序调用操作系统内核中的函数。

    18.分时系统中为什么需要进程表?在只有一个进程存在的计算机中,需要进程表吗、

    进程表是为了存储当前被挂起、甚或是被延迟和阻塞的进程状态。在单一进程的系统中是不需要,因为单一进程从不挂起。

    19、说明有没有理由在一个非空的目录中安装一个文件系统。如果这样做,如何做?

    装配文件系统将使得装配目录中已有的任何文件都不可访问,因此装配点通常都是空的。然而,系统管理人员可能需要将某些位于被装配目录中的非常重要的文件复制到装配点,使得他们在进行设备检查或修理时,可以在紧急事件中的普通路径上找到这些文件。

    20、对于下列系统调用,给出引起失败的条件:fork,exec以及unlink.

    如果进程表中没有空闲的槽(或者没有内存和交换空间),fork 将失败。如果所给的文件名不存在,或者不是一个有效的可执行文件,exec将失败。如果将要解除链接的文件不存在,或者调用unlink的进程没有权限,则unlink将失败。

    21.下列资源能使用哪种多路复用(时间、空间或者两者皆可):CPU、内存、磁盘、网卡、打印机、键盘以及显示器?

    时间复用:CPU,网卡,打印机,键盘。
    空间复用:内存,磁盘。
    两者:显示。
    

    22.在count = write(fd, buffer,nbytes);调用中,是否能将函数返回值传递给 count变量而不是nbtes变量?如果能,为什么?

    如果fd不正确,调用失败,将返回1。同样,如果磁盘满,调用也失败,要求写入的字节数和实际写入的字节数可能不等。在正确终止时,总是返回nbytes。

    23.有一个文件,其文件描述符是fd,内含下列字节序列:3,1,4,1,5,9,2,6,5,3,5。有如下系统调用:

    lseek(fd, 3, SEEK_SET);

    read(fd, &buffer, 4);

    其中lseek调用寻找文件中的字节3。在读操作完成之后,buffer中的内容是什么?

    答:1, 5, 9, 2

    24.假设一个10MB的文件在磁盘连续扇区的同一个轨道上(轨道号:50)。磁盘的磁头臂此时位于第100号轨道。要想从磁盘上找回这个文件,需要多长时间? 假设磁头臂从一个柱面移动到下一个柱面需要1ms,当文件的开始部分存储在的扇区旋转到磁头下需要5ms,并且读的速率是100MB/s。

    答:找到文件需要的时间=1 * 50 ms (移动到50轨道号的时间) + 5 ms (旋转到文件开始部分存储在的扇区的时间) + 10/100 * 1000 ms (读取10MB的时间) = 155 ms

    25.块特殊文件和字符特殊文件的基本差别是什么?

    答:块特殊文件包含被编号的块,每一块都可以独立地读取或者写入。而且可以定位于任何块,并且开始读出或写入。这些对于字符特殊文件是不可能的。

    26.在图1-7的例子中库调用称为read,而系统调用自身称为read,这两者都有相问的名字是正常的吗? 如果不是,哪一个更重要?

    系统调用实际上并没有名称,除了在文件中这样描述之外。当库例程read陷入内核时,它将系统调用号码放入寄存器或者堆栈中。该号码通常用于一张表的索引。这里确实没有使用任何名称。而另一方面,库例程的名称是十分重要的,因为它将用于程序中。

    27、现代操作系统将进程的地址空间从机器物理内存中分离出来,列举这种设计的两个好处。

    这允许可执行程序在不同的运行中 加载到机器内存的不同部分。 此外,它还使程序大小可以超过机器内存的大小(虚拟内存)。

    28、对程序员而言,系统调用就像对其他库过程的调用一样。有无必要让程序员了解哪一个库过程导致了系统调用?在什么情形下,为什么?

    答:就程序逻辑而言,库例程调用哪个系统调用是没有关系的。但是,如果需要考虑性能问题,无需系统调用就可以完成的任务将使程序运行更快。所有的系统调用都会导致用户环境和内核环境的切换开销。更进一步,在多用户系统中,在系统调用完成之前,操作系统可能调度到其他的进程,这将使得调用过程的处理更加迟缓。

    29、图1-23说明有一批UNIX的系统调用没有与之相等价的Win32 API,对于所列出的每一个没有Win32等价的调用,若程序员要把一个UNIX程序转换到Windows下运行,会有什么后果?

    答:某些 UNIX调用没有相应的Win32 API:

    Link: Win32程序不能给文件另外一个名称,或者使某个文件出现在多个目录中。同时,试图创建链接可以便于测试,并且在文件上加锁。

    Mount和umount: Wmdows程序不能创建关于标准的路径的假定命名,因为具有多个磁盘驱动器的系统上路径名,其驱动器部分是不同的。

    Chmod: Windows程序员不得不假定所有的用户都能访问每个文件。

    Kill: Windows程序员不能kill行为失常的程序。

    30、可移植的操作系统是能从一个系统体系结构到另一个体系结构的移动不需要任何修改的操作系统。请解释为什么建立一个完全可移植性的操作系统是不可行的。描述一下在设计一个髙度可移植的操作系统时你设计的高级的两层是什么样的。

    答:每一个系统体系结构都有它自己可以执行的一套指令。因此,奔腾不能执行SPARC程序或者SPARC无法执行奔腾程序。另外,不同的架构使用不同的总线架构(如VME总线,ISA,PCI,MCA,SBU,…)以及CPU的字长(通常是32或64位)。由于硬件上的这些差异,建立一个完全可移植的操作系统是不可行的。一个高度可移植的操作系统将包括两个高级层——一个机器相关层和一个机器独立层。机器相关层屏蔽硬件的细节,必须为每一个架构单独实现,该层提供了一个统一的接口。机器独立层只需要实现一次。为了实现高度可移植,机器相关层应尽可能小

    31、请解释在建立基于微内核的操作系统时策略与机制的分离带来的好处。

    答:策略和机制的分离,使操作系统的设计人员在内核中实现了少量的基本原语。这些原语被简化,因为它们不依赖于任何特定的策略。然后,它们在用户级别可以被用来实现更复杂的机制和策略。

    32、虚拟机由于很多因素而十分流行,然而他们也有一些缺点,给出一个缺点。

    虚拟化层引入了更多的内存使用和处理器开销以及更高的性能开销。

    33、下面是单位转换的练习:

    a)一微年是多少秒?

    b)微米常称为micron。那么gigamicron是多长?

    c) 1TB存储器中有多少字节?

    d)地球的质量是6000 yottagram, 换算成kilogram是多少?

    答:这些都可以直接转换:

    (a)一微年 = 10-6×365×24×3600 = 31.536 s。

    (b)1000m或lkm。

    ©有2^50字节,也就是1,099,511,627,776字节。

    (d)它是 6×10^24kg„

    34、写一个和图1-19类似的shell,但是包含足够的实际可工作的代码,这样读者可测试它。读者还可以添加某些功能,如输入输出重定向,管道以及后台作业。

    答:略。

    35、如果读者拥有一个个人UNIX类操作系统(Linux、MINIX、FreeBSD等),可以安全地崩溃和再启动,请写一个可以试图创建一个无限制数量子进程的shell脚本并观察所发生的事。在运行实验之前,通过shell键人sync,在磁盘上备好文件缓冲区以避免毁坏文件系统。注意:在没有得到系统管理员的允许之前,不要在分时系统上进行这一尝试,其后果将会立即发生,尝试者可能会被抓住并受到惩罚。

    答:略。

    36、用一个类似于UNIX od或MS-DOS DEBUG的程序考察并尝试解释UNIX类系统或Windows的目录。提示:如何进行取决于OS允许做什么。一个有益的技巧是在一个有某个操作系统的软盘上创建一个目录,然后使用一个允许进行此类访问的不同的操作系统读盘上的原始数据。

    答:略。

    展开全文
  • 题目略。 如有错误答案,请各位评论指出,多谢多谢 1、使用 .... /etc/passwd ...3、这些系统直接将程序加载到内存中,并在...第四,由于i节点导致性能混乱,其大小经过精心设计以适合块大小的文件将不再适合块大小。

    题目略。
    如有错误答案,请各位评论指出,多谢多谢

    1、使用 . 或 …切换文件路径

    /etc/passwd
    /./etc/passwd
    /././etc/passwd
    /./././etc/passwd
    /etc/../etc/passwd
    /etc/../etc/../etc/passwd
    /etc/../etc/../etc/../etc/passwd
    /etc/../etc/../etc/../etc/../etc/passwd
    

    2、Windows方法是使用文件扩展名。每个扩展名对应一个文件类型和一些处理该类型的程序。另一种方法是记住哪个程序创建了文件并运行该程序。麦金托什就是这样工作的。

    3、这些系统直接将程序加载到内存中,并在单词0处开始执行,这就是幻数。为了避免试图以代码的形式执行头,幻数是一条分支指令,目标地址就在头的上方。通过这种方式,可以将二进制文件直接读取到新进程的地址空间中,并在0处运行它,而不必知道头有多大。

    4、首先,如果没有打开,则每次读取时都需要指定要打开的文件的名称。然后,系统将不得不为它获取i节点,尽管可以缓存。快速出现的一个问题是何时将i节点刷新回磁盘。然而,它可能会超时。这可能有点笨拙,但可能会奏效。

    5、如果要再次读取文件,只需随机访问字节0。

    6、对。重命名调用不会更改创建时间或上次修改时间,但创建新文件会使其获取当前时间作为创建时间和上次修改时间。另外,如果磁盘快满了,复制可能会失败。

    7、文件的映射部分必须从页面边界开始,并且是页面长度的整数。每个映射页使用文件本身作为后备存储。未映射的内存使用暂存文件或分区作为备份存储。

    8、使用文件名,如/usr/ast/file。虽然它看起来像一个分层路径名,但实际上它只是一个包含嵌入斜杠的单一名称。

    9、一种方法是向读取系统调用添加一个额外的参数,该参数告诉您要从哪个广告中读取内容。实际上,每次读取都有可能在文件中进行查找。该方案的缺点是:(1)在ev ery read调用中有一个额外的参数;(2)要求用户跟踪文件点er的位置。

    10、dotdot组件将search移动到/usr,因此…/ast将其放入/usr/ast。因此…/ast/x与/usr/ast/x相同。

    11、由于浪费的存储在分配单元(文件)之间,而不是在它们内部,所以这是外部碎片。它与交换系统或使用纯分割的系统发生的主存储器外部碎片完全相似。

    12、如果一个数据块在一个连续的分配系统中损坏,那么只有这个块会受到影响;文件的其余块可以被读取。在链接分配的情况下,无法读取损坏的块;而且,从该损坏块开始的所有块的位置数据都将丢失。在索引分配的情况下,只影响损坏的数据块。

    13、启动传输需要9毫秒。要以80MB/秒的传输速率读取2 13字节,需要0.0977毫秒,总共需要9.0977毫秒。再写回去需要9.0977毫秒。因此,复制文件需要18.1954毫秒。要压缩16 GB磁盘的一半,需要复制8 GB的存储空间,即2 20个文件。在每个文件18.1954毫秒时,这需要19079.25秒,即5.3小时。显然,每次删除文件后压缩磁盘不是一个好主意。

    14、如果做得好,是的。压缩时,应组织每个文件,使其所有块都是连续的,以便快速访问。Windows有一个对磁盘进行碎片整理和重新组织的程序。鼓励用户定期运行它以提高系统性能。但考虑到需要多长时间,每月运行一次可能是一个很好的频率。

    15、数码照相机在非易失性存储介质(如闪存)上按顺序记录一些照片。当相机复位时,介质被清空。此后,图像按顺序一次记录一张,直到介质满为止,此时它们被上载到硬盘。对于此应用程序,相机内部(例如,在图片存储介质上)的连续文件系统是理想的。

    16、间接块可以容纳128个磁盘地址。与10个直接磁盘地址一起,最大文件有138个块。因为每个块都是1 KB,所以最大的文件是138 KB。

    17、对于随机访问,表/索引和连续都是合适的,而链接分配并不是因为它通常需要对给定记录进行多个磁盘读取。

    18、由于文件大小变化很大,连续分配将效率低下,需要重新分配磁盘空间,因为随着文件大小的增加,可用块的大小和压缩将随着文件大小的缩小而增加。链接和表/索引分配都将是有效的;在这两者之间,表/索引分配对于随机访问场景将更加有效。

    19、必须有一种方法来表示地址块指针保存数据,而不是指针。如果在属性中的某个地方有一点剩余,则可以使用它。这将为数据留下全部九个指针。如果指针都是K字节,则存储的文件可能长达9K字节。如果at属性中没有剩余任何位,则第一个磁盘地址可以保存一个无效地址,以将后面的字节标记为数据而不是指针。在这种情况下,最大文件为8kbytes。

    20、Elinor是对的。在表中同时拥有两个I节点副本是一种灾难,除非两者都是只读的。最坏的情况是两个都同时更新。当I节点被写回磁盘时,最后一个被写的节点将擦除另一个节点所做的更改,磁盘块将丢失。

    21、给定文件的所有硬链接目录项都指向单个i节点。对于软链接,将为软链接创建一个新的i节点,并且该i node基本上指向被链接的原始文件。

    22、给定文件的所有硬链接目录项都指向单个i节点。对于软链接,将为软链接创建一个新的i节点,并且该i node基本上指向被链接的原始文件。

    23、磁盘上的块数=4 TB/4 KB=2^30。因此,每个块广告地址可以是32位(4字节),最接近的2次方。因此,每个块可以存储4kb/4=1024个地址。

    24、位图需要B位。自由列表需要df位。如果d f<b,则空闲列表需要较少的位。或者,如果f/b<1/d,则空闲列表较短,其中f/b是空闲块的分数。对于16位磁盘地址,如果可用磁盘的6%或更少,则可用列表较短。

    25、位图的开头如下:

    (a) After writing file B: 1111 1111 1111 0000
    (b) After deleting file A: 1000 0001 1111 0000
    (c) After writing file C: 1111 1111 1111 1100
    (d) After deleting file B: 1111 1110 0000 1100
    

    26、这根本不是一个严重的问题。修复很简单,只需要时间,恢复算法是列出所有文件中的所有块,并将补码作为新的空闲列表。在Unix中,这可以通过扫描所有i节点来完成。在FAT文件系统中,由于没有空闲列表,因此无法发生问题。但即使有,恢复脂肪需要做的就是扫描脂肪寻找免费的条目。

    27、奥利的论文可能没有他希望的那样可靠。备份程序可以传递当前打开以供写入的文件,因为该文件中的数据状态可能不确定。

    28、它们必须跟踪磁盘上文件中最后一次转储的时间。在每次转储时,都会向该文件追加一个条目。在转储时,读取文件并记录最后一个条目的时间。从那时起更改的任何文件都会被转储。

    29、在(a)和(b)中,21不会被标记。在(c)中,没有变化。在(d)中,21不会被标记。

    30、许多Unix文件都很短。如果整个文件与i节点位于同一块中,则只需要一个磁盘访问来读取文件,而不是像目前的情况那样需要两个磁盘访问。即使对于较长的文件,也会有好处,因为只需要更少的磁盘访问。

    31、这不应该发生,但由于某个地方可能发生错误。这意味着某些块出现在两个文件中,并且在空闲列表中出现两次。修复错误的第一步是从空闲列表中删除两个副本。接下来,必须获取一个空闲块,并复制病态块的内容。最后,应该更改其中一个文件中出现的块,以引用新获取的块副本。此时,系统再次保持一致。

    32、所需时间为h+40×(1−h)。基址图只是一条直线。

    33、在这种情况下,最好使用直写缓存,因为它将数据写入硬盘,同时更新缓存。这将确保更新的文件始终位于外部硬盘上,即使用户在磁盘同步完成之前意外删除了硬盘。

    34、块预读技术在使用前按顺序读取块,以提高性能。在这个应用程序中,记录可能不会按顺序访问,因为用户可以在给定的时刻输入任何学生ID。因此,预读技术在这种情况下不会非常有用。

    35、分配给F1的区块有:22、19、15、17、21。
    分配给f2的区块有:16、23、14、18、20。

    36、在15000转/分时,磁盘需要4毫秒才能运行一次。读取k字节的平均访问时间(毫秒)为6+2+(k/1048776)×4。对于1 kb、2 kb和4 kb的块,访问时间分别约为6.0039 msec、6.0078 msec和6.0156 msec(几乎没有任何不同)。这些速率分别约为170.556 kb/秒、340.890 kb/秒和680.896 kb/秒。

    37、如果所有文件都是1KB,那么每个4KB块将包含一个文件和3KB的浪费空间。不允许在一个块中放置两个文件,因为用于跟踪数据的单位是块,而不是半块。这导致75%的空间浪费。在实践中,每个文件系统都有大文件和许多小文件,而且这些文件更有效地使用磁盘。例如,如果空间效率为32769/36864(约89%),32769字节的文件将使用9个磁盘块进行存储。

    38、间接块可以容纳1024个地址。在10个直接地址中,总共有1034个地址。由于每个指向一个4kb的磁盘块,所以最大的文件是4235264字节。

    39、它将所有文件长度的总和限制为不大于磁盘。这不是一个非常严重的限制。如果文件总的比磁盘大,那么就没有地方将它们全部存储在磁盘上。

    40、i节点可容纳10个指针。单个间接块包含1024个指针。双间接块适用于 1024^2 个指针。三个间接块适用于 1024^3个指针。加上这些,我们得到的最大文件大小为1074791434块,大约是16.06 GB。

    41、需要读取以下磁盘:

    directory for /
    i-node for /usr
    directory for /usr
    i-node for /usr/ast
    directory for /usr/ast
    i-node for /usr/ast/courses
    directory for /usr/ast/courses
    i-node for /usr/ast/courses/os
    directory for /usr/ast/courses/os
    i-node for /usr/ast/courses/os/handout.t
    

    总共需要读取10个磁盘。

    42、一些专业人士如下。首先,没有在未使用的i节点上浪费磁盘空间。第二,不可能耗尽i节点。第三,由于I节点和初始数据可以在一次操作中读取,因此需要较少的磁盘移动。一些缺点如下。首先,目录条目现在需要32位磁盘地址而不是16位i节点号。第二,整个磁盘甚至将用于不包含数据的文件(空文件、设备文件)。第三,由于需要读取每个i节点的整个块,并且i节点将分散在整个磁盘上,因此文件系统集成检查将变慢。第四,由于i节点导致性能混乱,其大小经过精心设计以适合块大小的文件将不再适合块大小。

    展开全文
  • 计算机操作系统第四版课后题答案汤小丹 第一章 1.设计现代OS的主要目标是什么?计算机操作系统第四版课后答案 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几个方面?计算机操作...
  • 操作系统第四版课后习题答案 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 第一章 1设计现代OS的主要目标是什么 答1...
  • 二,使用4位键,一次只能在内存中存储16个程序(其中一个是操作系统)。 2、答:这是一个巧合。基址寄存器的值为16384是因为程序恰好在地址16384上加载。程序可以在任何地方加载。界限寄存器为16384是因为程序...
  • 计算机操作系统第四版课后全部习题答案

    万次阅读 多人点赞 2019-04-01 19:09:22
    一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几个方面?...答:OS首先在裸机上覆盖一层I/O设备管理软件,实现了对计算机硬件操作...
  • 一章 1设计现代 OS的主要目标是什么 答 1 有效性 2 方便性 3 可扩充性 4 开放性 2OS的作用可表现在哪几个方面 答 1 OS 作为用户与计算机硬件系统之间的接口 2 OS 作为计算机系统资源的管理者 3 OS 实现了对计算机...
  • 操作系统第四版习题答案大全

    万次阅读 2016-07-14 16:44:46
    一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几...答:OS首先在裸机上覆盖一层I/O设备管理软件,实现了对计算机硬件操作一层次抽 象;在
  • 但是,图中只给出了种转换。有没有可能发生其他两种转换中的一个或两个? 从阻塞到运行的转换是可以想象的。假设某个进程在I/O上阻塞,而且I/O结束,如果此时CPU空闲,该进程就可以从阻塞态直接转到运行态。而...
  • 操作系统答案 第四版

    千次阅读 2018-10-22 18:26:26
    一章 1.设计现代 OS 的主要目标是什么? 答:( 1)有效性 ( 2)方便性 ( 3)可扩充性 ( 4)开放性 2. OS 的作用可表现在哪几个方面? 答:( 1) OS 作为用户与计算机硬件系统之间的接口 ) OS ...
  • 计算机操作系统第四版习题答案 第一章简答题

    千次阅读 热门讨论 2020-05-28 10:50:00
    1 .设计现代 OS 的主要目标是什么? 答:( 1 )有效性 ( 2 )方便性 ( 3 )可扩充性 ( 4 )开放性 ...答: OS 首先在裸机上覆盖一层 I/O 设备管理软件,实现了对计算机硬件操作一层次抽 象;在...
  • 计算机操作系统第四版)---第一章 操作系统引论 课后习题答案 **1.设计现代OS的主要目标是什么?** 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 **2.OS的作用可表现在哪几个方面?** 答:主要有...
  • 一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 ...在一层软件上再覆盖文件管理软件,实现了对硬件资源操作二层次抽象。OS 通 过在计算机硬件
  • 一章 1设计现代OS的主要目标是什么 答1有效性 2方便性 3可扩充性 4开放性 2OS的作用可表现在哪几个方面 答1OS作为用户与计算机硬件系统之间的接口 2OS作为计算机系统资源的管理者 3OS实现了对计算机资源的抽象 5...
  • 计算机操作系统(第四版)课后习题答案(完整版)

    万次阅读 多人点赞 2015-09-21 10:46:30
    一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几个方面?...答:OS首先在裸机上覆盖一层I/O设备管理软件,实现了对计算机硬件操作
  • 操作系统(第四版)汤晓丹第一章习题答案 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 第二章课后习题答案 设计现代os的...
  • 对传统操作系统(OS)和现代操作系统均做了较为全面的介绍。全书共分12章:一章为操作系统引论,介绍了OS的发展、传统OS和现代OS的特征及功能;二和三章深入阐述了进程和线程管理、进程同步、处理机调度和死锁;...
  • 计算机操作系统第四版--汤 小丹-课后习题答案 计算机操作系统第四版汤小丹课后习题答 第一章 设计现代OS的主要口标超什么? 答1有效性 2方便性 3町扩充性 4开放性 OS的作川对表现在哪几个方面 答I OS作为川户与计毎机...
  • 一章 1设计现代 OS 的主要目标是什么 答 1有效性 2 方便性 3可扩充性 4 开放性 2OS 的作用可表现在哪几个方面 答 1OS 作为用户与计算机硬件系统之间的接口 2 OS 作为计算机系统资源的管理者 3 OS 实现了对计算机...
  • 用户栈空间不足时不至于使操作系统崩溃. 五题 pow(1/2,5) = 1/32 六题 可以容纳的进程数: (4G - 512m) / 256m = 14 假设每个进程等待I/O的概率是 p 则14个进程都等待I/O的概率是 p^14 令 p ^ 14 = 1 - 0.99 = ...
  • 一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 ...在一层软件上再覆盖文件管理软件,实现了对硬件资源操作二层次抽象。OS 通 过在计算机硬件
  • 一章操作系统引论 1.设计现代OS的主要目标是什么? 答:(1)2有效性(2)方便性(3)可扩充性"(4)开放性 2.OS的作用可表现在哪几个方面? 答:(1)0S作为用户与计算机硬件系统之间的接口 (2)0S作为计算机系统资源的管理者 (3...
  • 计算机操作系统(第四版)课后习题答案

    万次阅读 多人点赞 2017-07-10 09:28:40
    一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几个方面?...答:OS首先在裸机上覆盖一层I/O设备管理软件,实现了对计算机硬件操作
  • 位于用户与操作系统之间的一层数据管理软件,用于科学地组织和存储数据、高效地获取和 维护数据。 DBMS 的主要功能包括数据定义功能、数据操纵功能、数据库的运行管理功能、 数据库的建立和维护功能。解析 DBMS 是一...

空空如也

空空如也

1 2 3 4 5
收藏数 90
精华内容 36
关键字:

现代操作系统第四版答案