La fonction Jemalloc en C

Dans n'importe quel langage de programmation, lorsque nous faisons du codage sur un certain problème, le codeur doit se souvenir de ses connaissances sur deux choses. L'un est la complexité du temps, et une autre est la complexité spatiale. La complexité de l'espace est la perspective la plus importante de programmation car la mémoire de notre appareil n'est pas illimité. Pour exécuter un programme avec moins de mémoire, améliorez notre capacité de programmation.

Se souvenant du concept précédent sur la complexité de l'espace, la fonction Jemalloc () est introduite dans le langage C pour augmenter nos performances de programmation.

Pourquoi la fonction Jemalloc () a-t-elle été introduite?

La fonction Jemalloc () est introduite dans le langage C pour améliorer les performances des programmes de serveur. Le programmeur contrôle tout programme de serveur pour apporter le concept de threading. Plusieurs threads s'exécutent d'une manière différente pour contrôler le programme serveur. La fonction Jemalloc () aide le programme du serveur à gérer sa complexité de mémoire en introduisant une mémoire minimale lors de l'exécution de ces threads.

Maintenant, la fonction Jemalloc () a son fichier d'en-tête dans le langage C. Il donne une meilleure option pour réduire l'inconvénient de la fonction malloc () ou de la fonction calloc () lorsque la mémoire est allouée dynamiquement pour les données ou les informations dans le langage C. Plus tôt, ces fonctions prédéfinies (malloc (), calloc ()) ont été utilisées. Mais, comme ces fonctions ont certaines limites liées aux performances de mémoire, la fonction Jemalloc () sera introduite dans le langage C.

Comment télécharger et installer le Jemalloc?

1. Pour télécharger la version mise à jour du Jemalloc, nous devons utiliser la commande suivante:

$ wget https: // github.com / jemalloc / jemalloc / sorties / téléchargement / 5.2.0 / Jemalloc-5.2.0.le goudron.bz2

Après avoir téléchargé le fichier à partir du site précédent, nous devons décompresser le fichier:

$ tar xjvf jemalloc-5.2.0.le goudron.bz2

2. Ensuite, nous ouvrirons la version téléchargée du Jemalloc-5.2.0 fichier.

$ CD Jemalloc-5.2.0 /

3. Après avoir ouvert le fichier, nous allons maintenant configurer le Jemalloc.

$ ./ configurer --with-jemalloc-prefix = je_

Pour configurer le Jemalloc, nous voulons indiquer dans quelle procédure la fonction Jemalloc sera compilée. Ici, la compilation sera effectuée pour Malloc dans le terme de JE_MALLOC, pour Calloc dans le terme de JE_CALLOC. Cela aidera à éviter toute situation déroutante avec la fonction du système LIBC du système Malloc.

Les étapes de configuration sont données ci-dessous, comme une forme de clichés:

Comment compiler Jemalloc

Pour compiler le fichier Jemalloc, nous devons installer faire. Pour cela, nous devons écrire un

$ sudo apt install make

Lorsque nous donnons le mot de passe et appuyons sur Entrée, la marque commencera à installer. Les étapes suivantes du processus d'installation de la marque sont données dans les captures d'écran suivantes:

Les fichiers de bibliothèque nouvellement générés

Une fois la configuration terminée, plusieurs fichiers de bibliothèque sont installés dans le répertoire Lib. Ils sont les suivants:

• • libjemalloc.un
  • libjemalloc_pic_a
  • libjemalloc.donc
  • libjemalloc.donc.2

Parmi ces fichiers de bibliothèque, LibJemalloc.A et LibJemalloc.donc.2 sont les fichiers de bibliothèque les plus importants. Le libjemalloc.Un fichier représente un fichier de bibliothèque statique et libjemalloc.donc.2 représente un fichier de bibliothèque dynamique.

Application de la fonction Jemalloc ()

Nous devons générer les trois répertoires suivants:

1. 1. $ mkdir jemalloctesting
   2. $ mkdir ./ Jemalloctesting / lib
   3. $ mkdir ./ Jemalloctesting / inclure

Copie des fichiers d'en-tête

Maintenant, nous allons copier le Jemalloc.H, jemalloc_defs.h, et libjemalloc.un fichier à l'intérieur et inclure Lib Jemalloc à l'intérieur de la bibliothèque Jemalloc.

Génération du fichier d'en-tête

Maintenant, nous générerons un fichier d'en-tête nommé userdefined_malloc.H. Ensuite, nous devons écrire plusieurs codes à l'intérieur de ce fichier d'en-tête. Les codes sont décrits ci-dessous:

Exemple de programmation 1

Créer un .C fichier C pour exécuter le code en incluant le "UserDefined_malloc.Fichier d'en-tête h ”.

#inclure
#inclure
#include «UserDefined_malloc.h ”
int main()

// c'est le pointeur (point) qui maintiendra l'adresse de base du bloc créé
int * point;
int n,
J;
// pour obtenir les chiffres de l'utilisateur
printf ("Entrer les numéros:");
scanf ("% d", & n);
printf ("Les nombres entrés par l'utilisateur:% d \ n", n);
// allouant la mémoire dynamiquement à l'aide de Malloc ()
point = (int *) malloc (n * sizeof (int));
// Vérification si la mémoire allouée par Malloc ()
if (point == null)

printf ("Mémoire non allouée.\ n ");
sortie (0);

autre

// Mémoire allouée
printf ("mémoire allouée avec succès par malloc () \ n");
// pour la boucle pour obtenir des éléments du tableau
pour (j = 0; j < n; ++j)
point [j] = j + 1;

// affichant tous les éléments présents dans le tableau
printf ("Les éléments du tableau sont:");
pour (j = 0; j < n; ++j)
printf ("% d,", point [j]);


printf ("\ n");
retour 0;

Générer le makefile

$ gedit makefile

Cc = gcc
Cflags = -wall -g
Inclut = -i ./inclure/
Alloc_dep =./ lib / libjemalloc.un
Alloc_link = $ (alloc_dep) -lpthread -ldl
Tests: tests.o
$ (Cc) $ (incluse) $ (cflags) -o test de test.o $ (alloc_link)
essai.O: test.C $ (alloc_dep)
$ (Cc) -c $ (incluse) $ (cflags) Test.c
faire le ménage:
Test de test RM -f.o

Sortir

$ faire
$ ./essai

Explication

Ici, nous essayons d'exécuter un programme de la fonction Jemalloc () en incluant le fichier d'en-tête nommé «Userdefined_malloc.h ”. Maintenant, nous entrons certaines valeurs de l'utilisateur et obtenons la mémoire dynamiquement en utilisant la fonction malloc (). La fonction malloc () crée un bloc de mémoire puis renvoie son adresse. Pour imprimer les valeurs, nous utilisons une boucle. La fonction Jemalloc () exécute avec succès ce programme en incluant le fichier d'en-tête dans le programme.

Vérifiez le programme à l'aide de l'outil GDB

$ gdb ./essai

Explication

Pour déboguer ou voir étape par étape le même programme, nous pouvons utiliser «$ Gdb ./essai". Nous tapons simplement «$ Gdb ./essai" Dans l'invite de commande et exécuter ce programme particulier à l'aide de commandes GDB comme «R», «S», «N», etc.

Exemple de programmation 2

Ici, nous essaierons de faire des opérations sur les données déjà supprimées par la fonction libre ().

#inclure
#inclure
#include "UserDefined_malloc.H "
int main ()

int * darray;
int i, n;
printf ("\ n Entrez la taille de Array =");
scanf ("% d", & n);
darray = (int *) malloc (n * sizeof (int));
printf ("\ n avant de mettre le contenu \ n");
pour (i = 0; i
printf ("% d \ n", darray [i]);

printf ("\ n Entrez% d elements = \ n", n);
pour (i = 0; i
scanf ("% d", & darray [i]);

printf ("\ n Les contenus du tableau sont \ n");
pour (i = 0; i
printf ("% d \ n", darray [i]);

darray = null;
libre (darray);
libre (darray);
printf ("\ n Après la libération de la mémoire \ n");
pour (i = 0; i
printf ("% d \ n", darray [i]);

printf ("\ n");

Compile et éxecute le programe

$ faire
$ ./essai

Exécuter en utilisant GDB

$ gdb ./essai

Explication

Dans cet exemple de programmation particulier, nous créerons un tableau dynamiquement à l'aide de la fonction malloc () et mettrons certaines valeurs de l'utilisateur à l'aide de For Loop. Ensuite, nous imprimons ces valeurs sur le moniteur. Après, nous traiterons la mémoire en appelant la fonction libre (). Cette fonction traite toute la mémoire créée dynamiquement par la fonction malloc ().

Après cela, si nous essayons d'imprimer à nouveau ces valeurs, étant donné que toutes les valeurs sont présentes dans le tableau et exécuter le programme, nous verrons une erreur comme "Segmentation fault (core dumped)". Parce qu'après avoir libéré la mémoire, si nous allons à nouveau effectuer des opérations sur ces valeurs, il n'est pas possible pratiquement car la fonction libre () supprime toutes les données.

Conclusion

Dans cet article, nous essayons de comprendre correctement la fonction Jemalloc (), à partir de son téléchargement, de l'installation, de la création d'un fichier d'en-tête et de l'exécution d'un programme. Il est très utile en utilisant la fonction Jemalloc () pour rendre la vie plus facile à d'autres fonctions, telles que malloc (), fonction calloc (), fonction realloc () et fonction libre (). La fonction Jemalloc () exécute avec succès ces fonctions dans le programme.