Hello this is a book problem of chapter 8 william stallings's operating systems..can anyone tells me the accurate solution of it??

The Unix kernel will dynamicaly grow a process’s stack in virtual memory as needed, but it willnever try to shrink it. Consider the case in which a program calls a C function that allocates a local arrayon the stack that consumes 10KB. The kernel will expand the stack segment to accommodate it. When thesubroutine returns, the stack pointer is adjusted and this space could be released by the kernel, but it is notreleased. Explain why it would be possible to shrink the stack at this point, and why the Unix kernel does not shrink it.

for {i=0, i<10000; i++} function_that_needs_a_lot_of_stack();

Do you really want to allocate and deallocate several stack pages 10000 times? Well I sure don't. So I disagree with the premise of the question. As a process reaches deeper into a stack it eventually tries to access unallocated pages. This causes a page fault and the page fault causes the kernel to allocate more space or terminate the process if the stack is exceeding a max. There is no coresponding mechanism to notify the kernel when a frame is removed from the stack. If the stack space is needed by the process again, you don't want to deallocate and reallocate the space repeatedly. If the stack space is not needed by the process and physical memory is tight, the unused stack pages will be paged out. If there is plenty of physical memory, they will sit harmlessly in memory. Shrinking a stack, while possible, would not be easy or desirable.

Usualy the stack allocation is not shrinked to keep track of things when a process behaves unexpectdly. So the remaining stack can provide some valueabel information for debugging!!

Another thing is that, in a system where memory is backed by disk, it doesn't have to shrink the stack to get it out of memory. It can swap extra pages to disk instead.

Another issue is how the stack is expanded. Detecting when something uses memory after the end of the current stack is easy -- detect page faults. But how are they supposed to detect when something is not using memory?

i am really getting confused with the points..
lets answer this question by taking any assumption..

So,

1. What can be the assumption.

2.Explain why it would be possible to shrink the stack at this point

3. and why the Unix kernel does not shrink it.

I think answering these questions will simplify the problem.

i am really getting confused with the points..
lets answer this question by taking any assumption..

So,

1. What can be the assumption.

2.Explain why it would be possible to shrink the stack at this point

3. and why the Unix kernel does not shrink it.

I think answering these questions will simplify the problem.

1) What?

2) Explain why it is? I don't think it is. Not efficiently, anyway.

3) It doesn't because that's not an efficient way to do it. I don't think Windows shrinks it either.

Like Per said, allocating and freeing memory 10,000 times is expensive. UNIX assumes that memory a process has used once, will probably be used again, so lets it keep it instead of slowing things down by trying to free it all the time.

There's a different strategy for paring down unused memory. The operating just looks for memory that hasn't been used recently. It might grab the end of the stack, or it might bite a page out of a shared library you've loaded, or pull page out of your global variables -- then save its contents to disk and give the memory to someone else. The operating system will remember what pieces it's taken from your process, and give them back if you try to use them.