4

したがって、各スレッドが少なくとも3種類の並行マップ（std :: map（いくつかのミューテックスを含む）と）で挿入、検索、削除を行う並列（100から10000の並列スレッドなど）の速度テストを実際に見たいと思います。libcds（並行データ構造） ..。

したがって、たとえば、そのような比較がまだ存在しない場合は、作成を手伝ってください。

直接関連： LibCds：MichaelHashmapとSplitOrder List

私たちが持っていると想像してください

#include <iostream>
#include <boost/thread.hpp>
#include <map>

class TestDs 
{
public:

    virtual bool containsKey(int key)=0;
    virtual int get(int key)=0;
    virtual int put(int key, int value)=0;
    virtual int remove(int key)=0;

    virtual int size()=0;
    virtual const char* name()=0;
    virtual void print()=0;
    virtual void shutdown()=0;
};

class GeneralMap: public TestDs
{
private:

    std::map<int,int> _ds;
    mutable boost::mutex mut_;
public:
    GeneralMap() {}

    bool containsKey(int key) {
        boost::mutex::scoped_lock lock(mut_);
        if ( _ds.find(key) != _ds.end())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    int get(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds[key];
    }

    int put(int key, int value) {
        boost::mutex::scoped_lock lock(mut_);
        _ds.insert(std::pair<int, int>(key,value));
        return key;
    }

    int remove(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.erase(key);
    }

    int size() {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.size();
    }
    const char* name() {
        return "StdMap";
    }
    void print() {}
    void shutdown() {}

};

N個のスレッドを作成し、各スレッドがcreateを呼び出し、deleteを見つけるようなテストを作成する方法よりも...何かを書き始めましたが、boost1.47.0でコンパイル可能なコードになりました...

#include <iostream>
#include <boost/thread.hpp>
#include <map>
#include <boost/thread.hpp>
#include <boost/thread/locks.hpp>
#include <boost/date_time.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random.hpp>
#include <boost/progress.hpp>

class timer 
{ 
public: 
    timer() : start_time_(boost::posix_time::microsec_clock::local_time()) {} 

    void restart() 
    {
        start_time_ = boost::posix_time::microsec_clock::local_time();
    } 

    boost::posix_time::time_duration elapsed() const 
    {
        return boost::posix_time::microsec_clock::local_time() - start_time_;
    } 
private: 
    boost::posix_time::ptime start_time_; 
};

class TestDs 
{
public:

    virtual bool containsKey(int key)=0;
    virtual int get(int key)=0;
    virtual int put(int key, int value)=0;
    virtual int remove(int key)=0;

    virtual int size()=0;
    virtual const char* name()=0;
    virtual void print()=0;
    virtual void shutdown()=0;
};

class GeneralMap: public TestDs
{
private:

    std::map<int,int> _ds;
    mutable boost::mutex mut_;
public:
    GeneralMap() {}

    bool containsKey(int key) {
        boost::mutex::scoped_lock lock(mut_);
        if ( _ds.find(key) != _ds.end())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    int get(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds[key];
    }

    int put(int key, int value) {
        boost::mutex::scoped_lock lock(mut_);
        _ds.insert(std::pair<int, int>(key,value));
        return key;
    }

    int remove(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.erase(key);
    }

    int size() {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.size();
    }
    const char* name() {
        return "StdMap";
    }
    void print() {}
    void shutdown() {}

};

template <class map_wraper_t>
class test_map_wraper
{
public:

    test_map_wraper(int threads_number)
    {
        n = threads_number;
    }

    void start_tests()
    {

        boost::upgrade_lock<boost::shared_mutex> lock(tests);
        boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);

        boost::shared_lock<boost::shared_mutex> lock_r(results);

        for(int i=0; i<n; i++)
        {
            boost::thread worker(&test_map_wraper::test, this, i);
        }
        boost::thread worker_r(&test_map_wraper::result, this);
        timerForCaptureFame.restart();
    }
private:
    int n;
    boost::shared_mutex  tests;
    boost::shared_mutex  results;
    boost::random::mt19937 rng;
    timer timerForCaptureFame;
    map_wraper_t Ds;
    boost::progress_display *show_progress;

    void test( int i)
    {
        boost::shared_lock<boost::shared_mutex> lock_r(results);
        boost::shared_lock<boost::shared_mutex> lock(tests);
        Ds.put(i, 0);
        if (Ds.containsKey(i))
        {
            Ds.get(i);
        }
        Ds.remove(i);
    }

    void result()
    {
        boost::upgrade_lock<boost::shared_mutex> lock(results);
        boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);

        std::cout <<  std::endl << "test of " << Ds.name() << " complite;" << std::endl << "test performed on " << n << " items" << std::endl << "test duration: " << timerForCaptureFame.elapsed() << std::endl;
    }
};


int main()
{
    int threads_n = 1000;
    int tests = 5;
    std::cout << "Number of required tests: " << tests << std::endl << "Number of threads in each test: " << threads_n << std::endl << "Wait for it..." << std::endl;
    //for(int i = 0; i < tests; ++i)
    //{
        test_map_wraper<GeneralMap> GeneralMapTest(threads_n);
        GeneralMapTest.start_tests();
    //}
    std::cin.get();
    return 0;
}
4

1 に答える 1

3

はい、LibCdsの単体テストに含まれています

ロックフリーの実装だけでなく、ロックありとロックなしのstd :: map / setを含む、あらゆる種類の異なるマップタイプで同じテストシナリオを実行します。

もちろん、同期が勝者となることは明らかではありませんが、ライターが混在している場合は機能しません。ロックフリーの実装は、同期アクセスを備えたSTLコンテナよりもはるかに高速に実行されます。

これはすべて驚くべきことではありません。なぜ質問するのですか？

PS。ユニットテストはここにあります：

  • タールボールを取得
  • エキス
  • ビルド（cd build && ./build.sh）
  • ユニットテストで、./bin/*/cds-unitまたは./bin/*/cds-unit-debugで構築されている場合--debug-test
于 2011-08-27T21:52:24.683 に答える