Início / coding / Perguntas / 79119461
Accepted
ABu
Asked: 2024-10-24 03:33:05 +0800 CST

Um programa vazio que não faz nada em C++ precisa de um heap de 204 KB, mas não em C

  • 772

Considere este programa vazio:

int main()
{ return 0; }

Se eu compilar com C++ com g++ main.cpp && strace ./a.out, e analisar a saída com strace, observei que as últimas linhas da saída são (você pode acrescentar -O3que o efeito é o mesmo):

mprotect(0x7f71af154000, 45056, PROT_READ) = 0
mprotect(0x7f71af38b000, 4096, PROT_READ) = 0
brk(NULL)                               = 0xed2000
brk(0xf05000)                           = 0xf05000
exit_group(0)                           = ?
+++ exited with 0 +++

No entanto, se eu fizer isso:gcc main.cpp && strace ./a.out

mprotect(0x7f4114318000, 16384, PROT_READ) = 0
mprotect(0x7f4114547000, 4096, PROT_READ) = 0
exit_group(0)                           = ?
+++ exited with 0 +++

Como você vê, em C++ há um extra brkque estende o heap em exatamente 204 KB (0xf05000 - 0xed2000 = 204 KB após traduzir ambos para decimal). Isso pode ser facilmente verificado substituindo esse programa por ( link coliru ):

#include <iostream>
#include <unistd.h>

int main()
{
    char buf[1024];
    sprintf(buf, "pmap -XX %u", getpid());
    std::system(buf);
    
    return 0;
}

e você pode facilmente observar que a compilação com g++o [heap]tem um tamanho de 204 KB, e com gcca [heap]linha até desapareceu da pmapsaída.

NOTA: A propósito, e para minha surpresa, o gcc não teve nenhum problema com include <iostream>e com a presença de stdin std::system.

Para que servem esses 204 KB? Não estou preocupado nem nada sobre esses pequenos 204 KB, mas eles chamaram minha atenção e estou curioso agora.

c++

1 respostas

  1. Best Answer

    Remova as bibliotecas adicionadas g++e não haverá alocação extra:

    g++ -nodefaultlibs -lc main.cpp

    Com as bibliotecas padrão, o programa C++ é vinculado a:

            /lib64/ld-linux-x86-64.so.2
        libc.so.6 => /lib64/libc.so.6
        libgcc_s.so.1 => /lib64/libgcc_s.so.1
        libm.so.6 => /lib64/libm.so.6
        libstdc++.so.6 => /lib64/libstdc++.so.6
        linux-vdso.so.1

    Sem as bibliotecas padrão + libc:

            /lib64/ld-linux-x86-64.so.2
        libc.so.6 => /lib64/libc.so.6
        linux-vdso.so.1

    As bibliotecas extras são:

            libgcc_s.so.1 => /lib64/libgcc_s.so.1
        libm.so.6 => /lib64/libm.so.6
        libstdc++.so.6 => /lib64/libstdc++.so.6

    De qualquer forma, eu me pergunto qual biblioteca C++ específica aumentou o heap

    Ao adicionar bibliotecas extras à vinculação, uma de cada vez, podemos ver que é isso libstdc++que causa a alocação extra. Portanto, se você puder dispensar a parte compilada da biblioteca padrão do C++, é isso que você pode usar:

    g++ -nodefaultlibs -lgcc_s -lm -lc

    A execução passo a passo do programa compilado com as bibliotecas padrão mostra a construção e a destruição de diversos objetos C++ padrão, como este std::atomic<std::shared_ptr<std::chrono::tzdb_list::_Node>>. O banco de dados de fuso horário sozinho deve ocupar um pouco de espaço, mas não tenho certeza se ele cobre todos os 2 KiB que você observou. A conclusão é, no entanto, que a biblioteca padrão C++ tem mais objetos (além daqueles na biblioteca padrão C) que são construídos implicitamente (os iostreams padrão, por exemplo):

    $ gdb -tui ./a.out
(gdb) layout asm
(gdb) start
(fiddling about for a long time)
(gdb) tui d
(gdb) bt
#0  std::atomic<std::shared_ptr<std::chrono::tzdb_list::_Node> >::~atomic (this=0x7ffff7e62810 <std::chrono::tzdb_list::_Node::_S_head_owner>, __in_chrg=<optimized out>)
    at /usr/src/debug/gcc-14.2.1-3.fc40.x86_64/obj-x86_64-redhat-linux/x86_64-redhat-linux/libstdc++-v3/include/bits/shared_ptr_atomic.h:630
#1  0x00007ffff7a51e60 in __cxa_finalize (d=0x7ffff7e52200) at cxa_finalize.c:82
#2  0x00007ffff7cb4947 in __do_global_dtors_aux () from /lib64/libstdc++.so.6
#3  0x00007fffffffd750 in ?? ()
#4  0x00007ffff7fc90f2 in _dl_call_fini (closure_map=0x7ffff7f8a000) at dl-call_fini.c:43
    • 27

relate perguntas