Sbrk() function in C

In this article, we will discuss the Sbrk() function in C with its syntax, parameters, and examples.

What is the sbrk() function?

The sbrk() function is used to modify the amount of memory space available for the calling process. It is done by adding incr bytes to the process's break value and allocating the required amount in space. The amount of allocated space grows when incr is more than zero and decreases when incr is less than zero. If the incr is zero, sbrk() returns the current program break value. This is a helper function that is invoked at the time of using the Standard C Library function malloc().

The sbrk() function adds incr characters to the break value and alters the space already allotted inturned. The value of incr can be negative, which means that the amount of allocated space is reduced.

The sbrk() is a system call function that allows the calling process to extend or decrease the size of the data segment for the process. The change is made by pointing and setting the process's break value and allocating an adequate amount of space. The break value is the address of the first location outside the data segment. As the break value increases, the amount of allocated space also increases.

Syntax:

It has the following syntax:

 
#include <unistd.h>
void* sbrk(intptr_t increment);   

This parameter defines the value by which the data segment size has to be shifted, and the number of bytes is expected here. The value needs to be positive to increase the heap size and negative to decrease it.

How does the sbrk() function work?

The heap is a part of a process's public address space used for dynamic memory allocation. The sbrk() function allows the program to expand or shrink this region by changing its break point.

Increase Memory: If the increment value passed to the sbrk() is positive, the size of the heap is extended by the corresponding number of bytes. This effectively shifts the breakpoint into higher address space, thus freeing up more address space for the program.
Decrease Memory: On the other hand, if sbrk() is called with a negative increment, the heap size is reduced, and the breakpoint is shifted to a lower address. It can be used to free up memory space for the system, such as using the ReleaseMemory method.

Return Value:

Success: If the execution of sbrk() is successful, it will provide the previous breakpoint address, that is the boundary of the data segment before the increment.
Failure: In case of failure, sbrk() returns (void *) -1 and sets the errno variable to indicate an error. Common errors include:

ENOMEM: Not enough memory to complete the request.

EINVAL: The increment

Example:

Let us take an example to illustrate the sbrk() method in C.

 
#include <unistd.h>
#include <stdio.h>
int main() {
    // The current breakpoint value
    void* current_break_value = sbrk(0);
    printf("Current break: %p\n", current_break_value);
    // The break is then increased to 1024 bytes
    if (sbrk(1024) == (void*) -1) {
        perror("The sbrk method is failed");
        return 1;
    }
    // The new break pint value
    void* new_break_value = sbrk(0);
    printf("The New break value is : %p\n", new_break_value);
    // The differences in the break point value
    printf("The value is increased by: %ld bytes\n", (char*)new_break_value - (char*)current_break_value);
    return 0;
}   

Output:

 
Current break: 0x1330000
The New break value is: 0x1351400
The value is increased by: 136192 bytes

Explanation:

This C program describes how the sbrk() function works to control the heaps. The program uses sbrk(0) to get the current breakpoint, which is the address of the end of the process's data segment, and stores this value in current_break_value. After that, it tries to increase the breakpoint further to 1024-byte larger using sbrk(1024), thereby asking the operating system for more than 1KB of memory. If the allocation is unsuccessful, the sbrk() returns (void*) -1 and the program uses the perror() to print an error message and then exits with the status code of 1. Upon successful allocation, the program uses sbrk(0) to obtain the new breakpoint and then subtracts the old breakpoint and gains the total byte difference. This difference is printed to the console to show how the heap size has increased as a result of the current index. Lastly, the program ends and returns the status code 0, denoting that the program has been executed successfully.

Conclusion:

In conclusion, the sbrk() function is the basic memory management operation in Unix-like systems that allows a program to manage the heap directly. Although it is not currently used directly in application programming to a significant extent, studying sbrk() is a good way to understand how memory management takes place at a more basic level. Current applications prefer using the higher-level memory management functions for the benefits of safety, portability, and usage. The sbrk() plays a crucial role in highlighting how memory management for programs has evolved historically in computing science.

Next TopicSine-series-in-c

← prev next →