18-1 Stacks on secondary storage

Consider implementing a stack in a computer that has a relatively small amount of fast primary memory and a relatively large amount of slower disk storage. The operations \(\text{PUSH}\) and \(\text{POP}\) work on single-word values. The stack we wish to support can grow to be much larger than can fit in memory, and thus most of it must be stored on disk.

A simple, but inefficient, stack implementation keeps the entire stack on disk. We maintain in - memory a stack pointer, which is the disk address of the top element on the stack. If the pointer has value \(p\), the top element is the \((p \mod m)\)th word on page \(\lfloor p / m \rfloor\) of the disk, where \(m\) is the number of words per page.

To implement the \(\text{PUSH}\) operation, we increment the stack pointer, read the appropriate page into memory from disk, copy the element to be pushed to the appropriate word on the page, and write the page back to disk. A \(\text{POP}\) operation is similar. We decrement the stack pointer, read in the appropriate page from disk, and return the top of the stack. We need not write back the page, since it was not modified.

Because disk operations are relatively expensive, we count two costs for any implementation: the total number of disk accesses and the total CPU time. Any disk access to a page of \(m\) words incurs charges of one disk access and \(\Theta(m)\) CPU time.

a. Asymptotically, what is the worst-case number of disk accesses for \(n\) stack operations using this simple implementation? What is the CPU time for \(n\) stack operations? (Express your answer in terms of \(m\) and \(n\) for this and subsequent parts.)

Now consider a stack implementation in which we keep one page of the stack in memory. (We also maintain a small amount of memory to keep track of which page is currently in memory.) We can perform a stack operation only if the relevant disk page resides in memory. If necessary, we can write the page currently in memory to the disk and read in the new page from the disk to memory. If the relevant disk page is already in memory, then no disk accesses are required.

b. What is the worst-case number of disk accesses required for \(n\) \(\text{PUSH}\) operations? What is the CPU time?

c. What is the worst-case number of disk accesses required for \(n\) stack operations? What is the CPU time?

Suppose that we now implement the stack by keeping two pages in memory (in addition to a small number of words for bookkeeping).

d. Describe how to manage the stack pages so that the amortized number of disk accesses for any stack operation is \(O(1 / m)\) and the amortized CPU time for any stack operation is \(O(1)\).

a. We will have to make a disk access for each stack operation. Since each of these disk operations takes time \(\Theta(m)\), the CPU time is \(\Theta(mn)\).

b. Since only every mth push starts a new page, the number of disk operations is approximately \(n / m\), and the CPU runtime is \(\Theta(n)\), since both the contribution from the cost of the disk access and the actual running of the push operations are both \(\Theta(n)\).

c. If we make a sequence of pushes until it just spills over onto the second page, then alternate popping and pulling many times, the asymptotic number of disk accesses and CPU time is of the same order as in part a. This is because when we are doing that alternating of pops and pushes, each one triggers a disk access.

d. We define the potential of the stack to be the absolute value of the difference between the current size of the stack and the most recently passed multiple of \(m\). This potential function means that the initial stack which has size \(0\), is also a multiple of \(m\), so the potential is zero. Also, as we do a stack operation we either increase or decrease the potential by one. For us to have to load a new page from disk and write an old one to disk, we would need to be at least \(m\) positions away from the most recently visited multiple of \(m\), because we would have had to just cross a page boundary. This cost of loading and storing a page takes (real) cpu time of \(\Theta(m)\). However, we just had a drop in the potential function of order \(\Theta(m)\). So, the amortized cost of this operation is \(O(1)\).

本页面的全部内容在 小熊老师 - 莆田青少年编程俱乐部 0594codes.cn 协议之条款下提供，附加条款亦可能应用