對無鎖隊列執行簡單的單元測試

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]; 
}