标签: heap

是否可以设置特定于应用程序的最大堆大小(dalvik.vm.heapsize属性),而不是对Android设备上运行的所有VM使用相同的最大堆大小？我知道我可以通过修改设备的AndroidRuntime.cpp作为root来设置新的dalvik heapsize,但是根据我读过的内容,因为Android只初始化VM一次然后分叉后续VM实例所有在设备上运行的VM都具有相同的dalvik .vm.heapsize属性.我是否正确地理解了这一点,并且有什么方法吗？

更新:此行似乎生成错误:*line = color;

我收到以下错误,但我不明白它可以来自哪里:

错误:

HEAP [testQt.exe]:0B444FE8处的堆块修改为0B44C6B0,请求大小为76c0

生成它的行:

return QPixmap::fromImage(qimage);

从:

QPixmap Interpolation::getData() {
    QPointF pt(0, 0);
    QRgb color;
    QImage qimage(m_width, m_height, QImage::Format_ARGB32);
    qimage.fill(Qt::transparent);

    for (int i(0); i < m_height; ++i) {
        m_progress->setValue(m_width+i);
        QRgb *line = (QRgb *)qimage.scanLine(i);
        for (int j(0); j < m_width; ++j) {
            pt.setX(j);
            pt.setY(i);
            line += 1;
            if (isInHull(pt)) {
                color = colorScale(interp(&pt));
                *line = color; //If I remove this part the program won't crash
            }
        }
    }  
    return QPixmap::fromImage(qimage);
}

如果它有帮助:

QRgb Interpolation::colorScale(qreal value) …

   typedef struct {
      void *elems;//address of the memory block
      int elemSize; //
      int logicLen;//number of existing elements in vector
      int allocLen;//allocated space for the vector
  } vector;

  static void InsertNumbers(vector *numbers, long n, long d)
  {
    long k;
    long residue;

    for (k = 0; k < d; k++) {
      residue = (long) (((long long)k * (long long) n) % d);
      VectorAppend(numbers, &residue);
    }
  }



void VectorAppend(vector *v, const void *elemAddr)
{
   void *target=(char*)v->elems + (v->logicLen * v->elemSize);

   if(v->logicLen==v->allocLen){
    v->allocLen*=2;
    v->elems=realloc(v->elems,v->allocLen*v->elemSize); …

我理解这个话题得到了很多回答.我的问题是针对它的说法或问题.

所以我说得对,用class关键字编写的代码将在托管堆上并且是一个引用类型,用struct编写的代码将在堆栈上并且是一个值类型？

如果我从我的程序(非守护程序进程)创建一个守护程序线程,堆和perm gen内存空间是否与新线程共享或是否重新分配？

如果守护程序线程有自己的空间,那么在新线程的创建中是否遵守了最大堆大小等JVM内存调整算法？

有人可以帮我解释下面的代码:

为什么char *s没有收到分配的内存点位置foo()？

#include <stdio.h>
#include <stdlib.h>

char *foo()
{
    char *s = (char *)malloc(20);
    s = "Hello Heap.";
    return s;
}

void bar(char *s)
{
    s = foo();
    printf("bar: %s\n", s); // Works fine just as expected.
}

int main()
{
    char *s;
    bar(s);
    printf("%s\n", s); // Output some undefined content like `H?}?H??`, other than `Hello Heap.`
}

可能重复:
Java VisualVM在OOME上启用堆转储

我有一个因OOME而崩溃的应用程序.我想在App崩溃之前不久创建堆的转储文件.jdump之前我用过几个小时的运行时来分析堆,但没有发现任何可疑之处.我可以在一些Eclipse分析器中运行该应用程序.在使用普通(或jdk)安装的服务器上抛出OOME之前不久,是否有某种方法可以创建堆转储？

我有这个代码:

class A {
    public:
            int x;
};

A *b;

void x() {
    A a;
    A *b = new A();
//  delete b; // works. free b.
}

int main() {
    x();
    delete b; //not. why ?
    return 0;
}

为什么b只能在x()中释放？不是主()？我认为b是一个手动变量,而不是范围限制.用valgrind检查.

谢谢.:)

更新:

现在我记得.我可以使用全局b:

b = new A();

然后main()上的删除b可以正确删除全局b.

*facepalm*

我对指针有疑问.这是我的问题:

编写一个函数int* read_data(int& size),cin通过输入Q 来读取数据,直到用户终止输入.该函数应将size参数设置为数字输入的数量.返回指向堆上数组的指针.该数组应具有完全大小的元素.当然,您不会在一开始就知道用户将输入多少元素.从10个元素的数组开始,每当数组填满时,大小加倍.最后,分配一个正确大小的数组并将所有输入复制到其中.一定要删除任何中间数组.

这是我的代码:

int* read_data(int& size);
int main()
{
    int size ;
    int* account_pointer = read_data(size);
    int* account_array = new int[size];

    int* bigger_array = new int[2 * size];
    for (int i = 0; i < size; i++)
    {
        bigger_array[i] = account_array[i];
    }
    delete[] account_array;
    account_array = bigger_array;
    size = 2 * size;

    system("PAUSE");
    return 0;
}

int* read_data(int& size)
{
    int input;
    cout << "Enter integer, Q to quit : " ;
    while(cin …

我在Java和C++中运行了一些小测试,创建了大量非常小的对象(没有类成员,构造函数中没有任何东西),而Java显然更快(我的意思是C++似乎非常慢).我敢打赌这与JVM有关,但是以哪种方式？

编辑:

我使用的类是这样的(因为我说没有类成员,在构造函数中没有做任何事)在C++中:

class foo{
    public:
        foo(){}
        ~foo(){}
}

在Java中:

public class Foo{
    public Foo(){}
}

我做的小测试只是关于在一个循环中分配大量的对象(连续大约1000000000).我在使用Linux的同一台机器上使用了GCC 4.7.2和Java 1.7到OpenJDK的实现.

我敢打赌,它确实与内存池分配有关,这表明JVM拥有不需要的内存.

我仍然感到困惑,因为我认为JVM实际上会更慢,计算指针引用和分配内存.