相同内存使用不同大小的矩阵

Question

当我发现奇怪的东西时，我对R中矩阵的内存使用感兴趣。在循环中，我使矩阵的列数增长，并为每个步骤计算对象大小，如下所示：

x <- 10
size <- matrix(1:x, x, 2)

for (i in 1:x){
  m  <- matrix(1, 2, i)
  size[i,2] <- object.size(m)
}

哪个给出了

plot(size[,1], size[,2], xlab="n columns", ylab="memory")

似乎具有2行和5,6,7或8列的矩阵使用完全相同的内存。我们怎么解释呢？

Answer 1

要了解这里发生了什么，你需要了解与R中的对象相关的内存开销。每个对象，甚至是没有数据的对象，都有40个字节的数据与之关联：

x0 <- numeric()
object.size(x0)
# 40 bytes

此内存用于存储对象的类型（由typeof()返回），以及内存管理所需的其他元数据。

忽略此开销后，您可能会期望向量的内存使用量与向量的长度成比例。让我们用几个图表来检查：

sizes <- sapply(0:50, function(n) object.size(seq_len(n)))
plot(c(0, 50), c(0, max(sizes)), xlab = "Length", ylab = "Bytes", 
  type = "n")
abline(h = 40, col = "grey80")
abline(h = 40 + 128, col = "grey80")
abline(a = 40, b = 4, col = "grey90", lwd = 4)
lines(sizes, type = "s")

看起来内存使用率大致与向量的长度成正比，但是在168字节处存在很大的不连续性，并且每隔几步就会出现小的不连续性。最大的不连续性是因为R有两个向量存储池：由R管理的小向量和由OS管理的大向量（这是一种性能优化，因为分配大量少量内存非常昂贵）。小向量只能是8,16,32,48,64或128字节长，一旦我们删除了40字节的开销，就是我们所看到的：

sizes - 40
#  [1]   0   8   8  16  16  32  32  32  32  48  48  48  48  64  64  64  64 128 128 128 128
# [22] 128 128 128 128 128 128 128 128 128 128 128 128 136 136 144 144 152 152 160 160 168
# [43] 168 176 176 184 184 192 192 200 200

从64到128的步骤导致了一大步，然后一旦我们进入大向量池，向量将以8个字节的块分配（内存以一定大小为单位，R可以＆＃ 39;要求半个单位）：

# diff(sizes)
#  [1]  8  0  8  0 16  0  0  0 16  0  0  0 16  0  0  0 64  0  0  0  0  0  0  0  0  0  0  0
# [29]  0  0  0  0  8  0  8  0  8  0  8  0  8  0  8  0  8  0  8  0  8  0

那么这种行为如何与你对矩阵看到的一致？好吧，首先我们需要查看与矩阵相关的开销：

xv <- numeric()
xm <- matrix(xv)

object.size(xm)
# 200 bytes

object.size(xm) - object.size(xv)
# 160 bytes

因此，与向量相比，矩阵需要额外的160字节存储空间。为什么160字节？这是因为矩阵的dim属性包含两个整数，属性存储在pairlist（较早版本的list()）中：

object.size(pairlist(dims = c(1L, 1L)))
# 160 bytes

如果我们使用矩阵而不是向量重新绘制前一个绘图，并将y轴上的所有常量增加160，则可以看到不连续性与从小向量池到大向量池的跳转完全对应：

msizes <- sapply(0:50, function(n) object.size(as.matrix(seq_len(n))))
plot(c(0, 50), c(160, max(msizes)), xlab = "Length", ylab = "Bytes", 
  type = "n")
abline(h = 40 + 160, col = "grey80")
abline(h = 40 + 160 + 128, col = "grey80")
abline(a = 40 + 160, b = 4, col = "grey90", lwd = 4)
lines(msizes, type = "s")

Answer 2

这似乎只发生在小端的非常特定的列范围内。查看1-100列的矩阵，我看到以下内容：

我没有看到任何其他的高原，即使我增加了列数，10000：

好奇，我进一步研究了一下，把你的代码放在一个函数中：

sizes <- function(nrow, ncol) {
  size=matrix(1:ncol,ncol,2)
  for (i in c(1:ncol)){
    m = matrix(1,nrow, i)
    size[i,2]=object.size(m)
  } 
  plot(size[,1], size[,2])
  size
}

有趣的是，如果我们增加行数，高原会缩小并向后移动，我们仍会看到这个高原和直线的数字很少，然后在我们点击nrow=8时最终调整到一条直线：

表明这种情况发生在矩阵中单元格数的非常特定的范围内; 9-16。

内存分配

正如@哈德利在评论中指出的那样，有一个类似的thread on memory allocation of vectors。为40 + 8 * floor(n / 2)大小为numeric的向量提供了公式：n。

对于矩阵，开销略有不同，并且步进关系不成立（如我的图中所示）。相反，我提出了公式208 + 8 * n字节，其中n是矩阵（nrow * ncol）中的单元格数，除了n介于9和16之间的位置： / p>

矩阵大小 - "double"矩阵的208个字节，1行，1-20列：

> sapply(1:20, function(x) { object.size(matrix(1, 1, x)) })-208
 [1]   0   8  24  24  40  40  56  56 120 120 120 120 120 120 120 120 128 136 144
[20] 152

但是。如果我们将矩阵的类型更改为Integer或Logical，我们会看到上面线程中描述的内存分配中的逐步行为：

矩阵大小 - "integer"矩阵的1个字节，1行，1-20列：

> sapply(1:20, function(x) { object.size(matrix(1L, 1, x)) })-208
 [1]   0   0   8   8  24  24  24  24  40  40  40  40  56  56  56  56 120 120 120
[20] 120

类似于"logical"矩阵：

> sapply(1:20, function(x) { object.size(matrix(1L, 1, x)) })-208
 [1]   0   0   8   8  24  24  24  24  40  40  40  40  56  56  56  56 120 120 120
[20] 120

令人惊讶的是，我们看不到类型为double的矩阵的相同行为，因为它只是附加"numeric"属性的dim向量（{{3} }）。

我们在内存分配中看到的重要一步来自R有两个内存池，一个用于小向量，一个用于大向量，这恰好是跳转的位置。 Hadley Wickham在回答中详细解释了这一点。

Answer 3

查看大小从1到20的数字向量，我得到了这个数字。

x=20
size=matrix(1:x,x,2)
for (i in c(1:x)){
   m = rep(1, i)
   size[i,2]=object.size(m)
}

plot(size[,1],size[,2])