On Sunday, March 4, 2012 11:13:42 AM UTC, wrote:
> Roman W <b...@g...pl> napisał(a):
>
> > On Sunday, March 4, 2012 5:46:00 AM UTC, M.M. wrote:
> > > Zawsze narzut na utworzenie watkow jest duzy, to nie wina OpenMP.
> >
> > Jezeli tworzysz watki recznie, narzut jest znacznie mniejszy.
>
> Mozesz to jakos uzasadnic i opisac jak uzywasz slowa "recznie"?
> Pozdrawiam

A kto pyta? ;-)

Mialem na mysli np. cos takiego:

#include <boost/thread.hpp>
#include <boost/timer.hpp>
#include <iostream>
#include <sstream>
#include <cmath>

template <class T> class global_data
{
public:
global_data(const T& data = T())
: m_data(data)
{
}

T& get() { return m_data; }
const T& get() const { return m_data; }
boost::mutex& mutex() { return m_mutex; }
private:
boost::mutex m_mutex;
T m_data;
};

template <class T> struct summator
{
summator(global_data<T>* d, T b, T e)
: begin(b), end(e), data(d)
{
}

void operator()()
{
T sum = T();
for (T i = begin; i < end; ++i)
sum += cos(i);
{
boost::lock_guard<boost::mutex> total_sum_lock(data->mutex());
data->get() += sum;
}
}

T begin;
T end;
global_data<T>* data;
};

template <class T> summator<T> make_summator(global_data<T>* d, T b, T e)
{
return summator<T>(d, b, e);
}

int main(int argc, char* argv[])
{
size_t n;
size_t d;
if (argc < 3) {
std::cerr << "Usage: " << argv[0] << " array-size number-of-threads" << std::endl;
return -1;
} else {
std::stringstream ss;
ss << argv[1];
ss >> n;
ss.clear();
ss << argv[2];
ss >> d;
}
if (n % d != 0) {
std::cerr << "array-size not exactly divisible by number-of-threads: " << n << "
and " << d << std::endl;
return -1;
}
const size_t s = n / d;
boost::thread_group tg;
global_data<double> total_sum(0.0);
for (size_t i = 0; i < d; ++i) {
tg.create_thread(make_summator(&total_sum, static_cast<double>(i*s), (i + 1.0)*s));
}
tg.join_all();
std::cout << "Total sum == " << total_sum.get() << std::endl;
}


Nawet dla parametrow przy ktorych program dziala tylko kilkanascie sekund (array-size
= 1000000) 2 watki wykonuja sie znacznie szybciej niz 1, a 4 to juz ho-ho.

RW