对无锁队列执行简单的单元测试

Question

我想比较不同的无锁队列的性能，因此，我想创建一个单元测试 - 其中包括推/弹出用户定义的预构建对象并从队列中。因此，我想问你几个问题： - 1）如何以简单的方式创建预先构建的对象。像我这样创建一个数组是否会达到目的。 2）我得到一个错误“终止调用后抛出'std :: system_error'实例什么（）：无效参数中止（核心转储）”。

Thanx提前。

#include <cstdlib> 
#include <stdio.h> 
#include <string> 
#include <chrono> 
#include <iostream> 
#include <ctime> 
#include <atomic> 
#include <thread> 
#include <boost/lockfree/queue.hpp> 

using namespace std; 

const long NUM_DATA = 10; 
const int NUM_PROD_THREAD = 2; 
const int NUM_CONSUM_THREAD = 2; 
const long NUM_ITEM = 1000000; 


class Data 
{ 
public: 
    Data(){} 
    void dataPrint() {cout << "Hello";} 
private: 
    long i; 
    double j; 
}; 


Data *DataArray = new Data[NUM_DATA]; 
boost::lockfree::queue<Data*> BoostQueue(1000); 

struct Producer 
{ 
    void operator()() 
    { 
     for(long i=0; i<1000000; i++) 
      BoostQueue.push(DataArray); 
    } 
}; 


struct Consumer 
{ 
    Data *pData; 
    void operator()() 
    { 
     while ( BoostQueue.pop(pData)) ; 
    } 
}; 


int main(int argc, char** argv) 
{ 
    std::thread thrd [NUM_PROD_THREAD + NUM_CONSUM_THREAD]; 

    std::chrono::duration<double> elapsed_seconds; 

    auto start = std::chrono::high_resolution_clock::now(); 
    for (int i = 0; i < NUM_PROD_THREAD; i++) 
    { 
     thrd[i] = std::thread{ Producer() }; 
    } 

    for (int i = 0; i < NUM_CONSUM_THREAD; i++) 
    { 
     thrd[NUM_PROD_THREAD+i] = std::thread{Consumer()}; 
    } 

    for (int i = 0; i < NUM_CONSUM_THREAD; i++) 
    { 
     thrd[i].join(); 
    } 

    auto end = std::chrono::high_resolution_clock::now(); 
    elapsed_seconds = end - start; 
    std::cout << "Enqueue and Dequeue 1 million item in:" << elapsed_seconds.count() << std::endl; 

    for (int i = 0; i < NUM_PROD_THREAD; i++) 
    { 
     thrd[i].join(); 
    } 

    return 0; 
} 

Answer 1

只是说明如何使用基准Data元素，虽然这确实测得的时间，这是不理想，但可能不是显著无论是内添加cout。

class Data 
{ 
public: 
    Data(long i) : i_(i) {} 
    void dataPrint() {cout << "Hello";} 
private: 
    long i_; 
    double j; 
}; 


Data* dataArray[1000000]; 
for (int i = 0; i < NUM_DATA; ++i) dataArray[i] = new Data(i); 

boost::lockfree::queue<Data*> BoostQueue(1000); 

struct Producer 
{ 
    void operator()() 
    { 
     for(long i=0; i<1000000; i++) 
      BoostQueue.push(dataArray[i]); 
    } 
}; 


struct Consumer 
{ 
    Data *pData; 
    long result_; 
    void operator()() 
    { 
     result_ = 0; 
     while ( BoostQueue.pop(pData)) 
      result_ += pData->i_; 
     std::cout << result_ << '\n'; 
    } 
}; 


int main(int argc, char** argv) 
{ 
    std::thread thrd [NUM_PROD_THREAD + NUM_CONSUM_THREAD]; 

    std::chrono::duration<double> elapsed_seconds; 

    auto start = std::chrono::high_resolution_clock::now(); 
    for (int i = 0; i < NUM_PROD_THREAD; i++) 
     thrd[i] = std::thread{ Producer() }; 

    for (int i = 0; i < NUM_CONSUM_THREAD; i++) 
     thrd[NUM_PROD_THREAD+i] = std::thread{Consumer()}; 

    for (int i = 0; i < NUM_CONSUM_THREAD; i++) 
     thrd[NUM_PROD_THREAD+i].join(); 

    auto end = std::chrono::high_resolution_clock::now(); 
    elapsed_seconds = end - start; 
    std::cout << "Enqueue and Dequeue 1 million item in:" 
     << elapsed_seconds.count() << std::endl; 

    for (int i = 0; i < NUM_PROD_THREAD; i++) 
     thrd[i].join(); 
    for (int i = 0; i < 1000000; ++i) 
     delete dataArray[i]; 
}