Question

作为一名前C程序员和当前的Erlang黑客，已经出现了一个问题。

如何估算我的erlang数据结构的内存范围？

让我说我在C中有一个1k整数数组，估计这个内存需求很容易，只是我的数组的大小，乘以一个整数的大小，1k 32位整数占用4kb或内存，还有一些恒定数量的指针和索引。

在erlang中，估计内存使用情况有点复杂，erlangs数组结构中的条目占用多少内存？，如何估计动态大小整数的大小。

我注意到在erlang中扫描数组中的整数是相当慢的，扫描一个大约1M整数的数组在erlang中花了将近一秒钟，而一段简单的c代码将在2周内完成，这很可能是由于数据结构占用的内存量。

我问这个，不是因为我是速度狂，而是因为估算内存至少在我的经验中是确定软件可扩展性的好方法。

我的测试代码：

首先是C代码：

#include <cstdio>
#include <cstdlib>
#include <time.h>

#include <queue>  
#include <iostream>

class DynamicArray{
protected:
  int* array;
  unsigned int size;
  unsigned int max_size;

public:
  DynamicArray() {
    array = new int[1];
    size = 0;
    max_size = 1;
  }

  ~DynamicArray() {
    delete[] array;
  }

  void insert(int value) {
    if (size == max_size) {
      int* old_array = array;
      array = new int[size * 2];
      memcpy ( array, old_array, sizeof(int)*size );

      for(int i = 0; i != size; i++)
        array[i] = old_array[i];
      max_size *= 2;
      delete[] old_array;
    }
    array[size] = value;
    size ++;
  }

  inline int read(unsigned idx) const {
    return array[idx];
  }

  void print_array() {
    for(int i = 0; i != size; i++)
      printf("%d ", array[i]);
    printf("\n ");

  }

  int size_of() const {
    return max_size * sizeof(int);
  }    

};


void test_array(int test) {
  printf(" %d ", test);
  clock_t t1,t2;
  t1=clock();
  DynamicArray arr;
  for(int i = 0; i != test; i++) {
    //arr.print_array();
    arr.insert(i);
  }
  int val = 0;
  for(int i = 0; i != test; i++)
    val += arr.read(i);
  printf(" size %g MB ", (arr.size_of()/(1024*1024.0)));  
  t2=clock();
  float diff ((float)t2-(float)t1);
  std::cout<<diff/1000<< " ms" ;
  printf(" %d \n", val == ((1 + test)*test)/2);
}

int main(int argc, char** argv) {
  int size = atoi(argv[1]);
  printf(" -- STARTING --\n");
  test_array(size);
  return 0;
}

和erlang代码：

-module(test).

-export([go/1]).

construct_list(Arr, Idx, Idx) ->
    Arr;
construct_list(Arr, Idx, Max) ->
    construct_list(array:set(Idx, Idx, Arr), Idx + 1, Max).

sum_list(_Arr, Idx, Idx, Sum) ->
    Sum;
sum_list(Arr, Idx, Max, Sum) ->
    sum_list(Arr, Idx + 1, Max, array:get(Idx, Arr) + Sum ).

go(Size) ->
    A0 = array:new(Size),
    A1 = construct_list(A0, 0, Size),
    sum_list(A1, 0, Size, 0).

定时c代码：

bash-3.2$ g++ -O3 test.cc -o test
bash-3.2$ ./test 1000000
 -- STARTING --
 1000000  size 4 MB 5.511 ms 0

和erlang代码：

1> f(Time), {Time, _} =timer:tc(test, go, [1000000]), Time/1000.0.
2189.418

Answer 1

这是你想要的吗？

1> erts_debug:size([1,2]).
4

有了它，你至少可以弄清楚一个术语有多大。返回的大小是单词。

Answer 2

首先，Erlang变量始终只是一个单词（32或64位，具体取决于您的机器）。该字的2位或更多位用作类型标记。余数可以保存“立即”值，例如“fixnum”整数，原子，空列表（[]）或Pid;或者它可以保存指向存储在堆上的数据的指针（元组，列表，“bignum”整数，浮点数等）。元组有一个标题字，用于指定其类型和长度，后跟每个元素一个字。列表单元格仅使用2个单词（其指针已编码类型）：头部和尾部元素。

例如：如果A = {foo，1，[]}，那么A是一个指向堆上的单词的单词，上面写着“我是一个3元组”，后跟3个包含原子foo的单词， fixnum 1和空列表。如果A = [1,2]，则A是表示“我是列表单元指针”的单词，指向第一个单元的头字（包含fixnum 1）;并且单元格的下一个尾词是另一个列表单元格指针，指向包含2的头字，后跟包含空列表的尾字。浮点由标题字和8个字节的双精度浮点数据表示。 bignum或二进制文件是标题字加上保存数据所需的字数。等等。参见例如http://stenmans.org/happi_blog/?p=176了解更多信息。

要估算大小，您需要知道您的数据是如何根据元组和列表构建的，并且您需要知道整数的大小（如果太大，它们将使用bignum而不是fixnum;限制是28位，包括32位机器上的标志，以及64位机器上的60位）。

编辑：https://github.com/happi/theBeamBook是BEAM Erlang虚拟机内部的新资源。

Answer 3

Erlang将整数称为“数组”，因此您无法以与c相同的方式对其进行估算，您只能预测整数的长度并计算存储它们所需的平均字节数

检查：http://www.erlang.org/doc/efficiency_guide/advanced.html您可以使用erlang:memory()功能确定实际金额

估计erlang数据结构的内存范围

3 个答案: