malloc_info(3) Library Functions Manual malloc_info(3) NOM malloc_info - Exporter l'etat de malloc vers un flux BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include int malloc_info(int options, FILE *stream); DESCRIPTION La fonction malloc_info() exporte une chaine XML decrivant l'etat actuel de l'allocation memoire pour l'appelant. Cette chaine est ecrite dans le flux stream. La chaine exportee contient des informations concernant toutes les domaines de memoires (<< arenas >>, consultez malloc(3)). Dans la mise en oeuvre actuelle, le parametre options doit etre nul. VALEUR RENVOYEE En cas de succes, malloc_info() renvoie 0. En cas d'erreur, -1 est renvoye et errno contient le code d'erreur. ERREURS EINVAL Le parametre options n'etait pas nul. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |malloc_info() | Securite des threads | MT-Safe | +---------------------------------+--------------------------+---------+ STANDARDS GNU. HISTORIQUE glibc 2.10. NOTES L'information d'allocation memoire est fournie sous forme de flux XML (plutot que de structure C), car les informations fournies pourront evoluer dans le futur, en raison de modifications dans le code mis en oeuvre. La sortie XML comporte un champ de version. La fonction open_memstream(3) peut etre utilisee pour envoyer la sortie de malloc_info() directement dans un tampon en memoire plutot que dans un fichier. La fonction malloc_info() est concue pour combler les manques de malloc_stats(3) et mallinfo(3). EXEMPLES Le programme ci-dessous accepte jusqu'a quatre parametres en ligne de commande dont les trois premiers sont obligatoires. Le premier parametre indique le nombre de processus legers (<< threads >>) que le programme doit creer. Tous les threads, thread principal compris, allouent le nombre de blocs de memoire indique en deuxieme parametre. Le troisieme parametre controle la taille des blocs a allouer. Le thread principal cree des blocs de cette taille, le deuxieme thread cree par le programme alloue des blocs deux fois plus grands, le troisieme thread alloue des blocs trois fois plus grands et ainsi de suite. Le programme appelle malloc_info() deux fois pour afficher l'etat de l'allocation memoire. Le premier appel est effectue avant la creation d'un thread ou l'allocation de memoire. Le deuxieme appel est effectue une fois que tous les threads ont alloue de la memoire. Dans l'exemple suivant, les parametres commandent la creation d'un thread additionnel, allouant 10 000 blocs de memoire, comme le thread principal. Une fois les blocs de memoire alloues, malloc_info() affiche l'etat des deux domaines de memoire. $ getconf GNU_LIBC_VERSION glibc 2.13 $ ./a.out 1 10000 100 ============ Before allocating blocks ============ ============ After allocating blocks ============ Source du programme #include #include #include #include #include #include static size_t blockSize; static size_t numThreads; static unsigned int numBlocks; static void * thread_func(void *arg) { int tn = (int) arg; /* The multiplier '(2 + tn)' ensures that each thread (including the main thread) allocates a different amount of memory. */ for (unsigned int j = 0; j < numBlocks; j++) if (malloc(blockSize * (2 + tn)) == NULL) err(EXIT_FAILURE, "malloc-thread"); sleep(100); /* Sleep until main thread terminates. */ return NULL; } int main(int argc, char *argv[]) { int sleepTime; pthread_t *thr; if (argc < 4) { fprintf(stderr, "%s num-threads num-blocks block-size [sleep-time]\n", argv[0]); exit(EXIT_FAILURE); } numThreads = atoi(argv[1]); numBlocks = atoi(argv[2]); blockSize = atoi(argv[3]); sleepTime = (argc > 4) ? atoi(argv[4]) : 0; thr = calloc(numThreads, sizeof(*thr)); if (thr == NULL) err(EXIT_FAILURE, "calloc"); printf("============ Before allocating blocks ============\n"); malloc_info(0, stdout); /* Create threads that allocate different amounts of memory. */ for (size_t tn = 0; tn < numThreads; tn++) { errno = pthread_create(&thr[tn], NULL, thread_func, (void *) tn); if (errno != 0) err(EXIT_FAILURE, "pthread_create"); /* If we add a sleep interval after the start-up of each thread, the threads likely won't contend for malloc mutexes, and therefore additional arenas won't be allocated (see malloc(3)). */ if (sleepTime > 0) sleep(sleepTime); } /* The main thread also allocates some memory. */ for (unsigned int j = 0; j < numBlocks; j++) if (malloc(blockSize) == NULL) err(EXIT_FAILURE, "malloc"); sleep(2); /* Give all threads a chance to complete allocations. */ printf("\n============ After allocating blocks ============\n"); malloc_info(0, stdout); exit(EXIT_SUCCESS); } VOIR AUSSI mallinfo(3), malloc(3), malloc_stats(3), mallopt(3), open_memstream(3) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Gregoire Scano Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 malloc_info(3)