当使用非常大的向量向量时,我们发现没有释放部分内存.
#include <iostream>
#include <vector>
#include <unistd.h>
void foo()
{
std::vector<std::vector<unsigned int> > voxelToPixel;
unsigned int numElem = 1<<27;
voxelToPixel.resize( numElem );
for (unsigned int idx=0; idx < numElem; idx++)
voxelToPixel.at(idx).push_back(idx);
}
int main()
{
foo();
std::cout << "End" << std::endl;
sleep(30);
return 0;
}
这将留下大约4GB的内存,直到进程结束.
如果我们将for行更改为
for (unsigned int idx=0; idx < numElem; idx++)
voxelToPixel.at(0).push_back(idx);
记忆被释放了.
使用gcc-4.8Linux机器上.我们习惯于htop在具有100 GB RAM的计算机上跟踪内存使用情况.您将需要大约8 GB的RAM来运行代码.你能重现这个问题吗？关于为什么会发生这种情况的任何想法？
编辑:我们已经看到,这不会发生在Mac(任何一个gcc或clang).此外,在linux中,如果我们调用foo两次(但第三次再次发生),则释放内存.
我有一个用Rust和wasm-bindgen编写的Web应用程序需要存储状态.状态存储如下:
lazy_static! {
static ref ID_TO_DATA: Mutex<HashMap<u32, Data>> = Mutex::new(HashMap::new());
}
pub struct Data {
pub coder_id: u16,
pub bools: Vec<bool>,
pub ints: Vec<i32>,
pub strings: Vec<String>,
}
我尝试以下方法删除数据并释放内存,并从中删除数据,HashMap并且不会报告错误:
#[wasm_bindgen]
pub fn remove_data(id: u32) {
match ID_TO_DATA.lock().unwrap().remove(&id) {
Some(data) => {
std::mem::drop(data);
}
None => {}
}
}
但是,浏览器选项卡使用的内存不会丢失(使用Chrome 67).我使用Windows的任务管理器,并观察相关进程/选项卡的内存增长到近2GB,然后在我的程序删除所有条目后,我等了一会儿,内存仍然接近2GB.
我也试过以下,但得到了这个错误: RuntimeError: memory access out of bounds
#[wasm_bindgen]
pub fn remove_data(id: u32) {
match ID_TO_DATA.lock().unwrap().remove(&id) {
Some(mut data) => {
unsafe {
std::ptr::drop_in_place(&mut data);
}
}
None => …我注意到Linux中有关内存使用情况(RES)的一些有趣行为top.我附加了以下程序,它在堆上分配了几百万个对象,每个对象都有一个大约1千字节的缓冲区.指向这些对象的指针由a std::list或a 跟踪std::vector.我注意到的有趣行为是,如果我使用a std::list,则报告的内存使用率top在睡眠期间永远不会改变.但是,如果我使用std::vector,那些睡眠期间内存使用率将降至接近0.
我的测试配置是:
Fedora Core 16
内核3.6.7-4
g ++版本4.6.3
我已经知道的:
1.std :: vector将根据需要重新分配(加倍大小).
2. std :: list(我相信)一次分配它的元素1.
std :: vector和std :: list默认使用std :: allocator来获取它们的实际内存
4.程序没有泄漏; valgrind宣称不可能泄漏.
令我困惑的是:
1.std :: vector和std :: list都使用std :: allocator.即使std :: vector正在进行批量重新分配,std :: allocator也不会以几乎相同的方式将内存分发给std :: list和std :: vector？毕竟这个程序是单线程的.
2.我在哪里可以了解Linux内存分配的行为.我听说过关于Linux保持RAM分配给进程的声明,即使它释放了它,但我不知道这种行为是否得到保证.为什么使用std :: vector会对这种行为产生如此大的影响？
非常感谢您阅读本文; 我知道这是一个相当模糊的问题.我在这里寻找的'答案'是这个行为是'定义'还是我可以找到它的文档.
#include <string.h>
#include <unistd.h>
#include <iostream>
#include <vector>
#include <list>
#include <iostream>
#include <memory>
class Foo{
public:
Foo()
{
data = …我有一个有类型字段的类unordered_map.我在我的应用程序中创建了这个对象的单个实例,它包含在一个shared_ptr.该对象非常耗费内存,我想在使用它后立即将其删除.但是,重置指针只会释放对象占用的一小部分内存.如何强制程序释放对象占用的所有内存？
以下模拟程序重现我的问题.for循环打印垃圾只是给我足够的时间来观察使用的内存top.析构函数刚刚被调用reset().此外,紧接着,使用的内存从大约2 GB下降到1.5 GB.
#include <iostream>
#include <memory>
#include <unordered_map>
using namespace std;
struct A {
~A() {
cerr << "Destructor" << endl;
}
unordered_map<int, int> index;
};
int main() {
shared_ptr<A> a = make_shared<A>();
for (size_t i = 0; i < 50000000; ++i) {
a->index[2*i] = i + 3;
}
// Do some random work.
for (size_t i = 0; i < 3000000; ++i) {
cout << "First" << endl;
} …在linux上,std :: deque在程序退出之前不会释放内存.完整的代码如下.任何帮助将不胜感激!
#include <deque>
#include <vector>
#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <queue>
#include <list>
#include <cstdio>
#include <cstdlib>
typedef boost::shared_ptr<std::vector<int> > VecPtr;
typedef std::deque< VecPtr > QueueType;
char buf[1024];
char line[1024];
int main()
{
{
int v=0;
QueueType deq;
for(int i=0; i<30;++i)
for(int j=0; j<1000;++j)
for(int k=0;k<1000;++k)
{
VecPtr p( new std::vector<int>);
deq.push_back(p);
}
std::cout<<"Done with increasing deq:deq size="<<deq.size()<<std::endl;
sleep(20);
std::cout<<"start decreasing deq size"<<std::endl;
while(deq.size()>0)
{
deq.pop_front();
}
std::cout<<"done with decreasing deq size,deq size="<<deq.size()<<std::endl;
}
std::cin.getline(line,sizeof(line));
return …