A função jemalloc em c

Em qualquer linguagem de programação, quando estamos fazendo alguma codificação em um determinado problema, o codificador deve lembrar seu conhecimento sobre duas coisas. Um é a complexidade do tempo, e outro é a complexidade do espaço. A complexidade espacial é a perspectiva mais importante de programação, pois a memória do dispositivo não é ilimitada. Para executar um programa com menos memória, aprimore nossa capacidade de programação.

Lembrando o conceito anterior sobre complexidade espacial, a função jemalloc () é introduzida na linguagem C para aumentar nosso desempenho de programação.

Por que a função jemalloc () foi introduzida?

A função jemalloc () é introduzida no idioma C para melhorar o desempenho dos programas do servidor. O programador controla qualquer programa de servidor para trazer o conceito de encadeamento. Vários threads são executados de uma maneira diferente para controlar o programa do servidor. A função jemalloc () ajuda o programa do servidor a gerenciar sua complexidade de memória, introduzindo memória mínima ao executar esses threads.

Agora, a função jemalloc () possui seu arquivo de cabeçalho na linguagem C. Ele oferece uma opção melhor para reduzir a desvantagem da função malloc () ou a função Calloc () quando a memória é alocada dinamicamente para os dados ou informações na linguagem C. Anteriormente, essas funções predefinidas (Malloc (), Calloc ()) foram usadas. Mas, como essas funções têm certas limitações relacionadas ao desempenho da memória, a função jemalloc () será introduzida na linguagem C.

Como baixar e instalar o jemalloc?

1. Para baixar a versão atualizada do Jemalloc, precisamos usar o seguinte comando:

$ wget https: // github.com/jemalloc/jemalloc/liberações/download/5.2.0/jemalloc-5.2.0.alcatrão.BZ2

Depois de baixar o arquivo do site anterior, precisamos descompactar o arquivo:

$ tar xjvf jemalloc-5.2.0.alcatrão.BZ2

2. Em seguida, abriremos a versão baixada do Jemalloc-5.2.0 arquivo.

$ CD Jemalloc-5.2.0/

3. Depois de abrir o arquivo, agora configuraremos o Jemalloc.

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

Para configurar o jemalloc, significa que queremos indicar em que procedimento a função jemalloc será compilada. Aqui, a compilação será feita para Malloc no termo de je_malloc, para Calloc no termo de je_calloc. Isso ajudará a evitar situações confusas com a função do sistema LIBC do sistema.

As etapas de configuração são fornecidas abaixo, como uma forma de instantâneos:

Como compilar Jemalloc

Para compilar o arquivo jemalloc, temos que instalar fazer. Para isso, temos que escrever um

$ sudo apt install make

Quando damos a senha e pressionamos Enter, a marca começará a instalar. As etapas a seguir do processo de instalação da marca são fornecidas nas capturas de tela a seguir:

Os arquivos de biblioteca recém -gerados

Depois que a configuração for concluída, vários arquivos da biblioteca são instalados no diretório Lib. Eles são os seguintes:

• • libjemalloc.a
  • libjemalloc_pic_a
  • libjemalloc.então
  • libjemalloc.então.2

Entre esses arquivos da biblioteca, libjemalloc.A e libjemalloc.então.2 são os arquivos de biblioteca mais importantes. O libjemalloc.Um arquivo representa um arquivo de biblioteca estática e libjemalloc.então.2 representa um arquivo de biblioteca dinâmica.

Aplicação da função jemalloc ()

Temos que gerar os três diretórios a seguir:

1. 1. $ mkdir jemalloctesting
   2. $ mkdir ./ jemalloctesting/ lib
   3. $ mkdir ./ jemalloctesting/ incluir

Copiando os arquivos de cabeçalho

Agora, vamos copiar o jemalloc.h, jemalloc_defs.h e libjemalloc.A arquivos dentro e inclui Lib Jemalloc dentro da Biblioteca Jemalloc.

Gerando arquivo de cabeçalho

Agora, geraremos um arquivo de cabeçalho chamado UserDefined_malloc.h. Então, temos que escrever vários códigos dentro deste arquivo de cabeçalho. Os códigos são descritos abaixo:

Exemplo de programação 1

Criando um .Arquivo C para executar o código incluindo o “userDefined_malloc.arquivo de cabeçalho H ”.

#incluir
#incluir
#include “userdefined_malloc.h "
int main ()

// este é o ponteiro (ponto) que manterá o endereço base do bloco criado
int* ponto;
int n,
j;
// para obter os números do usuário
printf ("Digite números:");
scanf ("%d", & n);
printf ("Os números inseridos pelo usuário: %d \ n", n);
// alocando a memória dinamicamente usando o Malloc ()
ponto = (int *) malloc (n * sizeof (int));
// verificando se a memória alocada por MALLOC () ou não
if (Point == NULL)

printf ("Memória não alocada.\ n ");
saída (0);

outro

// Memória alocada
printf ("Memória alocada com sucesso por malloc () \ n");
// para o loop para obter elementos da matriz
para (j = 0; j < n; ++j)
ponto [j] = j + 1;

// exibindo todos os elementos presentes na matriz
printf ("Os elementos da matriz são:");
para (j = 0; j < n; ++j)
printf ("%d", ponto [j]);


printf ("\ n");
retornar 0;

Gerando o makefile

$ gedit makefile

CC = GCC
Cflags = -wall -g
Inclui = -i ./incluir/
Aloc_dep =./lib/libjemalloc.a
Aloc_link = $ (aloc_dep) -lpthread -ldl
Teste: teste.o
$ (Cc) $ (inclui) $ (cflags) -o testes de teste.o $ (aloc_link)
teste.O: Teste.c $ (aloc_dep)
$ (Cc) -c $ (inclui) $ (cflags) testes.c
limpar:
teste de teste RM -F.o

Saída

$ make
$ ./teste

Explicação

Aqui, estamos tentando executar um programa da função jemalloc () incluindo o arquivo de cabeçalho nomeado “UserDefined_malloc.h ". Agora, inserimos alguns valores do usuário e obtemos memória dinamicamente usando a função MALLOC (). A função MALLOC () cria um bloco de memória e depois retorna seu endereço. Para imprimir os valores, usamos um loop. A função jemalloc () executa com sucesso este programa, incluindo o arquivo de cabeçalho no programa.

Verifique o programa usando a ferramenta GDB

$ GDB ./teste

Explicação

Para depurar ou ver passo a passo do mesmo programa, podemos usar “$ GDB ./teste ”. Nós simplesmente digitamos “$ GDB ./teste ” No prompt de comando e execute este programa específico com a ajuda de comandos do GDB como "R", "S", "N", etc.

Exemplo de programação 2

Aqui, tentaremos fazer algumas operações nos dados já removidos pela função gratuita ().

#incluir
#incluir
#include "userDefined_malloc.h "
int main ()

int *darray;
int i, n;
printf ("\ n digite o tamanho de Array =");
scanf ("%d", & n);
darray = (int *) malloc (n *sizeof (int));
printf ("\ n antes de colocar o conteúdo \ n");
para (i = 0; i
printf ("%d \ n", Darray [i]);

printf ("\ n enter %d elementos = \ n", n);
para (i = 0; i
scanf ("%d", & darray [i]);

printf ("\ n o conteúdo da matriz são \ n");
para (i = 0; i
printf ("%d \ n", Darray [i]);

darray = nulo;
grátis (Darray);
grátis (Darray);
printf ("\ n após liberar a memória \ n");
para (i = 0; i
printf ("%d \ n", Darray [i]);

printf ("\ n");

Compile e rode o programa

$ make
$ ./teste

Execute usando o GDB

$ GDB ./teste

Explicação

Neste exemplo de programação em particular, criaremos uma matriz dinamicamente com a ajuda da função MALLOC () e colocaremos alguns valores do usuário com a ajuda de loop. Em seguida, imprimimos esses valores no monitor. Depois, negociaremos a memória chamando a função gratuita (). Esta função negocia toda a memória criada dinamicamente pela função malloc ().

Depois disso, se tentarmos imprimir esses valores novamente, considerando que todos os valores estão presentes na matriz e executará o programa, veremos algum erro como "falha de segmentação (despejo de núcleo)". Porque depois de libertar a memória, se faremos novamente algumas operações nesses valores, não é possível praticamente, pois a função gratuita () remove todos os dados.

Conclusão

Neste artigo, estamos tentando entender a função jemalloc () corretamente, começando a partir de seu download, instalação, criação de arquivo de cabeçalho e executando um programa. É muito útil usando a função jemalloc () para facilitar a vida de outras funções, como Malloc (), Calloc () função, função realLoc () e função free (). A função jemalloc () executa com sucesso essas funções no programa.