Remembering the previous concept about space complexity, the jemalloc() function is introduced in the C language to boost our programming performance.
Why Was jemalloc() Function Introduced?
The jemalloc() function is introduced in the C language to improve the performance of the server programs. The programmer controls any server program to bring the concept of threading. Multiple threads execute in a different manner to control the server program. The jemalloc() function helps the server program manage its memory complexity by introducing minimum memory when executing these threads.
Now, the jemalloc() function has its header file in C language. It gives a better option to reduce the drawback of the malloc() function or calloc() function when memory is allocated dynamically for the data or information in C language. Earlier, these predefined functions (malloc(), calloc()) were used. But, as these functions have certain limitations related to memory performances, the jemalloc() function will be introduced in C language.
How To Download and Install the jemalloc?
1. To download the updated version of the jemalloc, we have to use the following command:
After downloading the file from the previous site, we have to unzip the file:
2. Next, we will open the downloaded version of the jemalloc-5.2.0 file.
3. After opening the file, we will now configure the jemalloc.
To configure the jemalloc means we want to indicate in what procedure the jemalloc function will be compiled. Here, compilation will be done for malloc in the term of je_malloc, for calloc in the term of je_calloc. This will help avoid any confusing situations with the system’s libc system function malloc.
The configuring steps are given below, as a form of snapshots:
How To Compile jemalloc
To compile the jemalloc file, we have to install make. For this, we have to write a
When we give the password and press enter, the make will start to install. The following steps of the installation process of make are given in the following screenshots:
The Newly Generated Library Files
After the configuration is done, several library files are installed in the lib directory. They are the following:
-
- libjemalloc.a
- libjemalloc_pic_a
- libjemalloc.so
- libjemalloc.so.2
Among these library files, libjemalloc.a and libjemalloc.so.2 are the most important library files. The libjemalloc.a file represents a static library file and libjemalloc.so.2 represents a dynamic library file.
Application of the jemalloc() Function
We have to generate the following three directories:
-
- $ mkdir jemalloctesting
- $ mkdir ./ jemalloctesting/lib
- $ mkdir ./ jemalloctesting/include
Copying the Header Files
Now, we will copy the jemalloc.h, jemalloc_defs.h, and libjemalloc.a files inside and include lib jemalloc inside the jemalloc library.
Generating Header File
Now, we will generate a header file named userdefined_malloc.h. Then, we have to write several codes inside this header file. The codes are described below:
Programming Example 1
Creating a .c file to run the code by including the “userdefined_malloc.h” header file.
#include <stdlib.h>
#include “userdefined_malloc.h”
int main()
{
//This is the pointer (point) that will hold the base address of the block created
int* point;
int n,
j;
// To get the numbers from the user
printf ("Enter Numbers : ");
scanf ("%d",&n);
printf ("The numbers entered by the user : %d\n", n);
// Allocating the memory dynamically using malloc()
point = (int*)malloc(n * sizeof(int));
// Checking if the memory allocated by malloc () or not
if (point == NULL)
{
printf ("Memory not allocated.\n");
exit(0);
}
else
{
// Memory allocated
printf ("memory allocated successfully by malloc ()\n");
// for loop to get elements of the array
for (j = 0; j < n; ++j) {
point[j] = j + 1;
}
// displaying all the elements present in the array
printf ("The elements of the array are: ");
for (j = 0; j < n; ++j) {
printf("%d, ", point[j]);
}
}
printf ("\n");
return 0;
}
Generating the Makefile
CFLAGS=-Wall -g
INCLUDES=-I ./include/
ALLOC_DEP=./lib/libjemalloc.a
ALLOC_LINK=$(ALLOC_DEP) -lpthread -ldl
testing: testing.o
$(CC) $(INCLUDES) $(CFLAGS) -o testing testing.o $(ALLOC_LINK)
testing.o: testing.c $(ALLOC_DEP)
$(CC) -c $(INCLUDES) $(CFLAGS) testing.c
clean:
rm -f testing testing.o
Output
$ ./testing
Explanation
Here, we are trying to run a program of the jemalloc() function by including the header file named “userdefined_malloc.h”. Now, we enter some values from the user and get memory dynamically by using the malloc() function. The malloc() function creates a block of memory and then returns its address. To print the values, we use a loop. The jemalloc() function successfully executes this program by including the header file in the program.
Check the Program Using the GDB Tool
Explanation
To debug or see step-by-step the same program, we can use “$ gdb ./testing”. We simply type “$ gdb ./testing” in the command prompt and run this particular program with the help of GDB commands like “r”, “s”, “n”, etc.
Programming Example 2
Here, we will try to do some operations on the data already removed by the free() function.
#include <stdlib.h>
#include "userdefined_malloc.h"
int main ()
{
int *darray;
int i,n;
printf ("\n Enter size of array = ");
scanf ("%d", &n);
darray = (int *) malloc (n*sizeof(int));
printf ("\n Before putting contents \n");
for (i=0; i<n; i++)
{
printf ("%d \n", darray[i]);
}
printf ("\n Enter %d elements = \n",n);
for (i= 0; i<n; i++)
{
scanf ("%d", &darray[i]);
}
printf ("\n The contents of the array are \n");
for (i=0; i<n; i++)
{
printf ("%d \n", darray[i]);
}
darray = NULL;
free (darray);
free (darray);
printf ("\n After freeing the memory \n");
for (i=0; i<n;i++)
{
printf ("%d \n", darray [i]);
}
printf ("\n");
}
Compile and Run the Program
$ ./testing
Run Using GDB
Explanation
In this particular programming example, we will create an array dynamically with the help of the malloc() function and put some values from the user with the help of for loop. Then, we print those values on the monitor. After, we will deallocate the memory by calling the free() function. This function deallocates all the memory created dynamically by the malloc() function.
After that, if we try to print those values again, considering all the values are present in the array, and run the program, we will see some error like “segmentation fault (core dumped)”. Because after freeing the memory, if we will again do some operations on those values, it is not possible practically as the free() function removes all the data.
Conclusion
In this article, we are trying to understand the jemalloc() function properly, starting from its download, installation, creating header file, and running a program. It is very useful using the jemalloc() function to make life easier to other functions, such as malloc(), calloc() function, realloc() function, and free() function. The jemalloc() function successfully executes these functions in the program.
