QVector的内存分配策略

我们都知道 STL std::vector 作为动态数组在所分配的内存被填满时,如果继续添加数据,std::vector 会另外申请一个大小当前容量两倍的区域(如果 n > size 则申请 n+当前容量 的空间),然后把当前内容拷贝到新的内存,以达到动态扩容的效果:
   size_type
      _M_check_len(size_type __n, const char* __s) const
      {
        if (max_size() - size() < __n)
          __throw_length_error(__N(__s));

        const size_type __len = size() + std::max(size(), __n);
        return (__len < size() || __len > max_size()) ? max_size() : __len;
      }


最直观的方式是写个客户程序看看:
vector<int> ve(4, 8);
    cout << "size : " << ve.size() << " capacity : " << ve.capacity() << endl;

    for ( int i = 0; i < 14; ++i )
    {
        ve.push_back(9);
        ve.push_back(0);
        cout << "size : " << ve.size() << " capacity : " << ve.capacity() << endl;
    }


输出如下,capacity 每次扩张为之前容量的两倍:
QVector的内存分配策略_第1张图片

类似的,Qt在其 QTL 中也实现了类似的QVector,为了更方便地服务为 Qt 应用服务,它提供了隐式共享,写时复制等机制,并同时提供了 Java Style 和 C++ Style 的接口,相同功能的接口也就是换了个名字而已:
inline void push_back(const T &t) { append(t); }


那么, QVector 所分配的内存被填满时,它的内存又是以何种方式扩充的呢?我们可以在源码中一探究竟:
先看看 QVector::append():
const bool isTooSmall = uint(d->size + 1) > d->alloc;
    if (!isDetached() || isTooSmall) {
        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
        reallocData(d->size, isTooSmall ? d->size + 1 : d->alloc, opt);
    }


isDetached()调用一个引用计数,用来判断该QVector是否独立(未被隐式共享)。如果该 QVector 是被共享的,那么我们此时想要在这个已被我们“复制”的 QVector 上调用 append() 时,当然需要真正分配一段新的内存并在该内存上进行添加元素的操作,也就是所谓的“写时复制”。

isTooSmall 则告诉我们当前szie加 1 之后是否超出了当前容量(d->alloc),如果是同样需要调用 reallocData 开始申请内存。由于内存分配可能是由写时复制策略调用,因此根据 isTooSmall 参数的不同,reallocData()的参数也不同。

QVector::reallocData()函数调用了QTypedArrayData::allocate(),前者执行了begin(),end()等指针的重新指向,原内存释放等工作,后者实际调用了 QArrayData::allocate(),其函数原型为:
static QTypedArrayData *allocate(size_t capacity,
            AllocationOptions options = Default) Q_REQUIRED_RESULT
    {
        Q_STATIC_ASSERT(sizeof(QTypedArrayData) == sizeof(QArrayData));
        return static_cast<QTypedArrayData *>(QArrayData::allocate(sizeof(T),
                    Q_ALIGNOF(AlignmentDummy), capacity, options));
    }


这里的 Q_ALIGNOF(AlignmentDummy) 十分关键,AlignmentDummy是下面这样的一个class:
class AlignmentDummy { QArrayData header; T data; };

QArrayData 是 Qt 所有连续型容器实际存放数据的地方,包含以下几个数据成员,也就是说,在32位机器上(以下以此为默认环境),sizeof(QArrayData) 一般是16个字节长度:
QtPrivate::RefCount ref;
    int size;
    uint alloc : 31;
    uint capacityReserved : 1;

    qptrdiff offset; // in bytes from beginning of header


而 Q_ALIGNOF 在 gcc 下是 __alignof__ 的别名,而在MSVC下则为 __alignof,用来获得 AlignmentDummy 的内存对齐大小,由上面的数据成员可以知道 Q_ALIGNOF(QArrayData) 的值为4。当 Q_ALIGNOF(AlignmentDummy) 大于4 时,意味着该 QArrayData 的成员变量所占内存空间与实际 T 型数据间由于内存对齐将会存在间隙(padding),因此我们需要额外多申请 padding 的空间才能保证所有数据都能够被正确安放。

理解这一点后,我们就可以来看看QArrayData::allocate()
QArrayData *QArrayData::allocate(size_t objectSize, size_t alignment,
        size_t capacity, AllocationOptions options)
{
    // 检测aligment是否为2的阶数倍
    Q_ASSERT(alignment >= Q_ALIGNOF(QArrayData)
            && !(alignment & (alignment - 1)));

    ...

    // 获取 QArrayData 类为空时的大小
    size_t headerSize = sizeof(QArrayData);

    // 申请额外的 alignment-Q_ALIGNOF(QArrayData)大小的 padding 字节数
    // 这样就能将数据放在合适的位置上
    if (!(options & RawData))
        headerSize += (alignment - Q_ALIGNOF(QArrayData));

    // 如果数组长度超出容量则申请新的内存
    if (options & Grow)
        capacity = qAllocMore(int(objectSize * capacity), int(headerSize)) / int(objectSize);

    //一共需要申请的字节数
    size_t allocSize = headerSize + objectSize * capacity;

    QArrayData *header = static_cast<QArrayData *>(::malloc(allocSize));
    if (header) {
        ...
    }

    return header;
}



qAllocMore() 实现在 qbyteArray.cpp 文件中,这个函数返回一个整型数,返回数据内容所需的字节数:
int qAllocMore(int alloc, int extra)
{
    Q_ASSERT(alloc >= 0 && extra >= 0);
    Q_ASSERT_X(alloc < (1 << 30) - extra, "qAllocMore", "Requested size is too large!");

    unsigned nalloc = alloc + extra;

    // Round up to next power of 2

    // Assuming container is growing, always overshoot
    //--nalloc;

    nalloc |= nalloc >> 1;
    nalloc |= nalloc >> 2;
    nalloc |= nalloc >> 4;
    nalloc |= nalloc >> 8;
    nalloc |= nalloc >> 16;
    ++nalloc;

    Q_ASSERT(nalloc > unsigned(alloc + extra));

    return nalloc - extra;
}


函数开头告诉我们如果申请字节不能超过 2^30 - extra。注意这里的 extra 就是我们在上面求到的 sizeof(QArrayData) + sizeof(padding)。alloc是我们存放实际数据区域的大小,nalloc即为我们总共需要的新内存容量。
下面的几排移位算法如果大家眼熟的话应该知道得到的 nalloc 的新值为比其原值大的一个最近的 2 的阶乘数,比如输入20,经过最后一步 ++nalloc 操作后,nalloc将变成 32。


拨开云雾见青天的时候终于要到了,回到我们最初的问题:QVector 在满容量之后继续插入,其内存增长策略如何?
按照我们前面所看到的,大家心里也许有了答案:QVector的所申请内存大小按照 2^n 增长,也就是 2, 4, 8, 16, 32...OK,写测试代码的时候到了:
    QVector<int> ve(2, 8);
    qDebug() << "size : " << ve.size() << " capacity : " << ve.capacity();

    for ( int i = 0; i < 20; ++i )
    {
        ve.append(9);
        qDebug() << "size : " << ve.size() << " capacity : " << ve.capacity();
    }

输入如下:
QVector的内存分配策略_第2张图片

似乎有些奇怪,容量(占用内存为 capacity * sizeof(int))并不是 2 的 n 次方?还记得QArrayData类中的数据成员所占用的 sizeof(QArrayData) = 16 吗,正是这 16 个字节占用了我们这个QVector<int>的 4 个容量,也就是说,这个QVector<int>实际的容量应该为:
QVector的内存分配策略_第3张图片

现在我们再考虑带有 padding 的情况,当我们创建一个 QVector<quint64> 时,由于内存对齐的关系,QArrayData的数据成员与实际存储数据之间应该存在间隙,导致不可用的空间超过 16 字节:
QVector的内存分配策略_第4张图片
可以看到,实际空间占用比容量大了 3*8 = 24bytes,其中 16bytes 为 headerSize,余下 8bytes 则为间隙了。
这样应该很清晰了吧(●'◡'●)


那么,这个分配策略和 STL std::vector 的差异主要在哪呢,不也是每次翻倍吗?
使用int作为数组数据类型,直接给个输出结果哈:
QVector的内存分配策略_第5张图片

同样向 100 个容量的满数组中添加一个数据,QVector扩容将申请 128*4 (16字节headerSize) 个字节,而 std::vector 将申请 200*4 个字节。
就先到这里吧~


你可能感兴趣的:(C++,vector,内存分配,QVector,QTL)