The simpler form of allocation is static allocation.
Storage space once allocated was never released.
So a very simple storage allocation model that allocated storage, as required, from one end of the available space towards the other, was adequate.
Early programming languages, such as FORTRAN, had static storage, the amount of which was known at compile time.
Static storage allocation is efficient since no time or space is expended for storage management during execution.
The translator can generate a direct value address for all data items.
It is incompatible with recursive subprogram calls, with data structures whose size is dependent on computed or input data, and with many other desirable language features.
Stack Based Storage Management:
It is the simpler run-time storage management technique.
Storage allocation begins at one end.
Storage must be freed in the reverse order of allocation so block allocated space recently must free the space first.
Only a single stack pointer is all that is needed to control storage management.
The stack pointer always points to the top of the stack, the next available word of free storage in the stack block.
Compaction occurs automatically as part of freeing storage.
Freeing a block of storage automatically recovers the freed storage and makes it available for reuse.
We know that most of the time program and data elements requiring storage are tied to subprogram activations.
When a subprogram is called, per call a new activation record is created on the top of the stack and termination causes its deletion from the stack.
The Heap Storage Management
The heap is used for the storage of values which may require to be accessible from the time the storage is allocated until the program terminates.
The major problem that arises in this type of allocation is that how to reallocate or reuse the allocated space.
Some of the languages like C follow the following method to reallocated the allocated space: ptr = malloc (6);
The above statement allocates six bytes of space and returns a pointer to it.
Now, these storage spaces may become inaccessible due to program actions such as reassignment to pointers; etc.
ptr = ptrnew;
Now ptr contains the address of ptrnew and space allocated by the above malloc (6) statement becomes inaccessible.
There remains the possibility that the space concerned is accessible via some other variables. Consider the effect of executing an assignment such as
ptr1 = ptr;
This assignment would make the space allocated by malloc accessible via the variable ptr1.
But we have no method by which we can know which of the path a program will follow at run time. This means the code to reclaim heap space cannot be generated at compile-time, despite the fact that large areas of space allocated on the heap can actually become inaccessible.
Language C provides the facility to free the space as follows: free (ptr);
But these kinds of facilities put a considerable responsibility on the programmer.
Now languages are available in which programmer’s responsibility to free inaccessible storage is automatic, for example, JAVA provides facilities to do so.
Incidentally, JAVA stores arrays on the heap, unlike the storage models as above. All objects are also stored on a heap.