第5回　タスク並列とデータ並列の違い

#ifndef SHARED_QUEUE_HXX
#define SHARED_QUEUE_HXX

#include <queue>
#include <boost/thread.hpp>

template < typename T >
class SharedQueue
{
private:
    std::queue < T > m_que;
    boost::mutex m_mtx;
    boost::condition_variable m_not_empty;

public:
    void enqueue(const T & x)
    {
        {
            boost::lock_guard < boost::mutex > lock(m_mtx);
            m_que.push(x);
        }
        m_not_empty.notify_one();
    }

    T dequeue(void)
    {
        boost::unique_lock < boost::mutex > lock(m_mtx);
        while (m_que.empty()) m_not_empty.wait(lock);
        T x = m_que.front();
        m_que.pop();
        return x;
    }
};

#endif /* SHARED_QUEUE_HXX */

//#include <iostream>
//#include <iterator>
#include <vector>
#include <cmath>
#include <boost/thread.hpp>
#include <boost/progress.hpp>
#include "shared_queue.hxx"

class PrimeCalc
{
private:
    std::vector<int> & m_prime_vector;
    SharedQueue<int> & m_shared_queue;

public:
    PrimeCalc(std::vector<int> & prime_vector, SharedQueue<int> & shared_queue)
            : m_prime_vector(prime_vector), m_shared_queue(shared_queue) {}
    void operator () (void)
    {
        while (true)
        {
            int n = m_shared_queue.dequeue();
            if (0 == n) break;
            bool prime_flag = true;
            int square_root = static_cast <int> (sqrt(n));
            for (int j = 3; j <= square_root; j += 2)
            {
                if (0 == (n % j))
                {
                    prime_flag = false;
                    break;
                }
            }
            if (true == prime_flag)
            {
                m_prime_vector.push_back(n);
            }
        }
    }
};

int main(void)
{
    std::vector<int> v0;        /* prime vector */
    std::vector<int> v1;        /* prime vector */
    SharedQueue<int> sq;

    for (int i = 3; i <= 999999; i += 2)
    {
        sq.enqueue(i);
    }
    sq.enqueue(0);
    sq.enqueue(0);

    PrimeCalc pc0(v0, sq);
    PrimeCalc pc1(v1, sq);

    {
        boost::progress_timer pt;

        boost::thread th0(pc0);
        boost::thread th1(pc1);

        th0.join();
        th1.join();
    }

    //std::copy(v0.begin(), v0.end(), std::ostream_iterator<int>(std::cout, " "));
    //std::copy(v1.begin(), v1.end(), std::ostream_iterator<int>(std::cout, " "));
    //std::cout << std::endl;

    return 0;
}