Question

我正在数据库上工作，而不是在RocksDB上运行。我有一个find函数，该函数接受参数中的查询，遍历数据库中的所有文档，然后返回与查询匹配的文档。我想并行化此函数，以便将工作分散在多个线程上。

为此，我尝试使用ThreadPool：我将循环的代码移到了lambda中，并为每个文档的线程池添加了一个任务。循环之后，每个结果都由主线程处理。

当前版本（单线程）：

void
EmbeDB::find(const bson_t& query,
             DocumentPtrCallback callback,
             int32_t limit,
             const bson_t* projection)
{
    int32_t count = 0;
    bson_error_t error;
    uint32_t num_query_keys = bson_count_keys(&query);
    mongoc_matcher_t* matcher = num_query_keys != 0
        ? mongoc_matcher_new(&query, &error)
        : nullptr;

    if (num_query_keys != 0 && matcher == nullptr)
    {
        callback(&error, nullptr);
        return;
    }

    bson_t document;
    rocksdb::Iterator* it = _db->NewIterator(rocksdb::ReadOptions());
    for (it->SeekToFirst(); it->Valid(); it->Next())
    {
        const char* bson_data = (const char*)it->value().data();
        int bson_length = it->value().size();
        std::vector<char> decrypted_data;
        if (encryptionEnabled())
        {
            decrypted_data.resize(bson_length);
            bson_length = decrypt_data(bson_data, bson_length, decrypted_data.data(), _encryption_method, _encryption_key, _encryption_iv);
            bson_data = decrypted_data.data();
        }
        bson_init_static(&document, (const uint8_t*)bson_data, bson_length);

        if (num_query_keys == 0 || mongoc_matcher_match(matcher, &document))
        {
            ++count;

            if (projection != nullptr)
            {
                bson_error_t error;
                bson_t projected;
                bson_init(&projected);

                mongoc_matcher_projection_execute_noop(
                    &document,
                    projection,
                    &projected,
                    &error,
                    NULL
                );

                callback(nullptr, &projected);
            }
            else
            {
                callback(nullptr, &document);
            }

            if (limit >= 0 && count >= limit)
            {
                break;
            }
        }
    }
    delete it;

    if (matcher)
    {
        mongoc_matcher_destroy(matcher);
    }
}

新版本（多线程）：

void
EmbeDB::find(const bson_t& query,
             DocumentPtrCallback callback,
             int32_t limit,
             const bson_t* projection)
{
    int32_t count = 0;
    bool limit_reached = limit == 0;
    bson_error_t error;
    uint32_t num_query_keys = bson_count_keys(&query);
    mongoc_matcher_t* matcher = num_query_keys != 0
        ? mongoc_matcher_new(&query, &error)
        : nullptr;

    if (num_query_keys != 0 && matcher == nullptr)
    {
        callback(&error, nullptr);
        return;
    }

    auto process_document = [this, projection, num_query_keys, matcher](const char* bson_data, int bson_length) -> bson_t*
    {
        std::vector<char> decrypted_data;
        if (encryptionEnabled())
        {
            decrypted_data.resize(bson_length);
            bson_length = decrypt_data(bson_data, bson_length, decrypted_data.data(), _encryption_method, _encryption_key, _encryption_iv);
            bson_data = decrypted_data.data();
        }

        bson_t* document = new bson_t();

        bson_init_static(document, (const uint8_t*)bson_data, bson_length);

        if (num_query_keys == 0 || mongoc_matcher_match(matcher, document))
        {
            if (projection != nullptr)
            {
                bson_error_t error;
                bson_t* projected = new bson_t();
                bson_init(projected);

                mongoc_matcher_projection_execute_noop(
                    document,
                    projection,
                    projected,
                    &error,
                    NULL
                );

                delete document;

                return projected;
            }
            else
            {
                return document;
            }
        }
        else
        {
            delete document;

            return nullptr;
        }

    };

    const int WORKER_COUNT = std::max(1u, std::thread::hardware_concurrency());

    ThreadPool pool(WORKER_COUNT);
    std::vector<std::future<bson_t*>> futures;

    bson_t document;
    rocksdb::Iterator* db_it = _db->NewIterator(rocksdb::ReadOptions());
    for (db_it->SeekToFirst(); db_it->Valid(); db_it->Next())
    {
        const char* bson_data = (const char*)db_it->value().data();
        int bson_length = db_it->value().size();

        futures.push_back(pool.enqueue(process_document, bson_data, bson_length));
    }
    delete db_it;

    for (auto it = futures.begin(); it != futures.end(); ++it)
    {
        bson_t* result = it->get();

        if (result)
        {
            count += 1;

            if (limit < 0 || count < limit)
            {
                callback(nullptr, result);
            }

            delete result;
        }
    }

    if (matcher)
    {
        mongoc_matcher_destroy(matcher);
    }
}

通过简单的文档和查询，单线程版本在我的计算机上 0.5秒处理了100万个文档。
使用相同的文档和查询，多线程版本在 3.3秒中处理了100万个文档。

令人惊讶的是，多线程版本要慢得多。此外，我测量了执行时间，并且 75％的时间都花在了for循环中。因此，基本上futures.push_back(pool.enqueue(process_document, bson_data, bson_length));行花费了75％的时间。

我做了以下事情：

我检查了WORKER_COUNT的值，它在我的机器上是6。
我试图添加futures.reserve(1000000)，以为向量重新分配可能有问题，但没有任何改变。
我试图删除动态内存分配（bson_t* document = new bson_t();），但并没有明显改变结果。

所以我的问题是：多线程版本比单线程版本要慢，这是我做错了吗？

我目前的理解是，线程池的同步操作（当任务入队和出队时）仅消耗大部分时间，解决方案是更改数据结构。有想法吗？

Answer 1

并行化具有开销。

处理单线程版本的每个文档大约需要500纳秒。要把工作委派给线程池，必须做很多记账工作（既要委派工作，又要在事后进行同步），而每个记账工作很可能需要超过500纳秒。

假设您的代码正确，那么每个工作簿记大约需要2800纳秒。为了从并行化中获得显着的加速，您将需要将工作分解为更大的块。

我建议尝试一次处理1000个批次的文档。每个未来，而不是仅对应于一个文档，将对应于1000个文档。

其他优化

如果可能，避免不必要的复制。如果某个东西被复制了一堆，请查看是否可以通过引用而不是通过值来捕获它。

使用线程池并行化函数会使速度变慢：为什么？

1 个答案:

并行化具有开销。

其他优化