检查Groovy版本Gradle正在使用(Checking Groovy version Gradle is using)

 首先，您没有使用未使用的vector进行任何测试。 编译器是聪明的，并且-O2 gcc和clang都将上面的代码编译为空的main() （除了单个xor eax, eax以设置返回值。请参阅此处的程序集。此外，大多数vector的默认构造函数实现（包括gcc和clang ）甚至不会分配任何东西 - 它会等到第一个元素被添加之后再进行昂贵的分配步骤。 
 
 要获得更具体的结果，请分配一个BIG向量（以便将其与噪声区分开）并将其传递给另一个转换单元中的方法（或在单独的.cpp文件中定义），如下所示： 
 
#include <vector>

void sink(std::vector<int>& v);

int main() {
    std::vector<int> v(12345678);
    sink(v);
}
 
 现在，当您检查程序集时，您会发现它实际上正在执行某些操作 。 
 
 因此，Valgrind报告的~72,000字节与您的std::vector<int> v无关，您可能会看到完全为空的main的相同数字。 
 
 问题和引用文献的想法仍然与该问题不同，我将在下面回答。 
 
 程序退出时， 所有内存通常都会释放回操作系统，操作系统会强制执行此操作，而不是标准库。 操作系统只是清理进程使用的所有资源，包括非共享内存分配。 当Valgrind提到“在退出时使用”时，它正在讨论此操作系统清理之前，因为这是您想要知道的，看看您是否忘记释放任何东西。 
 
 您不需要任何单独的过程。 它只是意味着Valgrind可以跟踪malloc和free调用以及其他一些标准分配例程，但是标准库可能会在需要malloc 最初调用malloc （或者operator new或某些等价物）的那些上面使用另一层，但是当内存由进程取消分配，它将内部保存在某个列表中，而不是调用相应的取消分配例程（例如free ）。 在后续分配中，它将使用其列表中的内容而不是返回标准方法（如果列表已用尽，则必须调用标准例程）。 由于旧版本的C ++中std::allocator定义有些无用，因此没有大量使用，但它在更新的标准中有所改变。 最大的好处是（a）为容器使用线程局部的固定大小分配，因为所有包含的对象大小相同，并且（b）允许分配器在容器被销毁时释放一个操作中的所有内容而不是逐个元素释放。 
 
 你引用的文档有点令人困惑，因为它谈到（不）重新调整内存到操作系统 - 但它应该说“重新调整到标准分配例程”。 Valgrind不需要将内存返回到操作系统以将其视为已释放 - 它会挂钩所有标准例程并知道何时释放该级别。 标准例程本身大量“缓存”分配的内存，如上所述（这是常见的，不像分配器例程缓存，这是不常见的），因此如果Valgrind需要将内存返回到操作系统，那么报告“退出时分配的内存”将毫无用处。 

 
 
How does the C++ library implementation achieve that?
 
 
It doesn't. The valgrind information is outdated, I don't think any modern C++ implementations do that.
 
 
 
Does it keep around a separate process in the background that handles all allocation requests from its standard templates, so that when the program exits (a.out here), the memory is not immediately given back to the OS?
 
 
No, you've misunderstood. The valgrind docs aren't talking about keeping memory around that outlives the process. It's just talking about keeping memory pools within the process so that memory allocated and then deallocated by the process is kept in a pool and reused (by the same process!) later, instead of calling free immediately. But nobody does that for std::allocator nowadays, because std::allocator needs to be general purpose and perform reasonably well in all scenarios, and a good malloc implementation should meet those needs anyway. It's also fairly easy for users to override the default system malloc with an alternative like tcmalloc or jemalloc, so if std::allocator just forwards to malloc then it gets all the benefits of that replacement malloc.
 
 
 
If so, when will it give back, and how can I check the process indeed exists? If not, what is the "magic" behind the scene?
 
 
All memory in a process is returned to the OS when the process exits. There is no magic.
 
But the allocation you're seeing has nothing to do with this anyway.
 
 
 
There is 71 KB allocated. Why this number?
 
 
The 72kb you're seeing is allocated by the C++ runtime for its "emergency exception-handling pool". This pool is used to be able to allocate exception objects (such as bad_alloc exceptions) even when malloc can no longer allocate anything. We pre-allocate at startup, so if malloc runs out of memory we can still throw bad_alloc exceptions.
 
The specific number comes from this code:
 
       // Allocate the arena - we could add a GLIBCXX_EH_ARENA_SIZE environment
       // to make this tunable.
       arena_size = (EMERGENCY_OBJ_SIZE * EMERGENCY_OBJ_COUNT
                     + EMERGENCY_OBJ_COUNT * sizeof (__cxa_dependent_exception));
       arena = (char *)malloc (arena_size);
 
See https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=libstdc%2B%2B-v3/libsupc%2B%2B/eh_alloc.cc;h=005c28dbb1146c28715ac69f013ae41e3492f992;hb=HEAD#l117
 
Newer versions of valgrind know about this emergency EH pool and call a special function to free it right before the process exits, so that you don't see in use at exit: 72,704 bytes in 1 blocks. This was done because too many people fail to understand that memory still in use (and still reachable) is not a leak, and people kept complaining about it. So now valgrind frees it, just to stop people complaining. When not running under valgrind the pool doesn't get freed, because doing so is unnecessary (the OS will reclaim it when the process exits anyway).