void lock_and_wait( mutex& m , barrier& b0 , barrier& b1 , fifo_type& hpxthreads , std::size_t wait ) { // Wait for all hpxthreads in this iteration to be created. b0.wait(); const thread_id_type this_ = get_self_id(); while (true) { // Try to acquire the mutex. boost::unique_lock<mutex> l(m, boost::try_to_lock); if (l.owns_lock()) { hpxthreads.push(new std::pair<thread_id_type, std::size_t> (this_, get_thread_phase(this_))); break; } // Schedule a wakeup. set_thread_state(this_, milliseconds(30), pending); // Suspend this HPX thread. hpx::this_thread::suspend(suspended); } // Make hpx_main wait for us to finish. b1.wait(); }
void suspend_test(barrier& b, std::size_t iterations, std::size_t n) { for (std::size_t i = 0; i < iterations; ++i) { // Enter the 'suspended' state for n microseconds. hpx::this_thread::suspend(microseconds(n), "suspend_test"); } // Wait for all hpx-threads to enter the barrier. b.wait(); }
void operator()(Iterator first,Iterator last, std::vector<value_type>& buffer, unsigned i,barrier& b) { value_type& ith_element=*(first+i); bool update_source=false; for(unsigned step=0,stride=1;stride<=i;++step,stride*=2) { value_type const& source=(step%2)? buffer[i]:ith_element; value_type& dest=(step%2)? ith_element:buffer[i]; value_type const& addend=(step%2)? buffer[i-stride]:*(first+i-stride); dest=source+addend; update_source=!(step%2); b.wait(); } if(update_source) { ith_element=buffer[i]; } b.done_waiting(); }
void local_barrier_test(barrier& b, boost::atomic<std::size_t>& c) { ++c; // wait for all threads to enter the barrier b.wait(); }
void threadfunc(double Wi, double Wf, double mu, vector<double> xi, double tauf, queue<input>& inputs, vector<results>& res, progress_display& progress, barrier& bar, int thread) { // DynamicsProblem* prob; // // { // prob = new DynamicsProblem(Wi, Wf, mu, xi); // } DynamicsProblem prob(Wi, Wf, mu, xi); bar.wait(); for (;;) { input in; { boost::mutex::scoped_lock lock(inputs_mutex); if (inputs.empty()) { break; } in = inputs.front(); inputs.pop(); } double tau = in.tau; results pointRes; pointRes.tau = tau; try { prob.evolve(tau, pointRes); // prob->evolve(tau, pointRes); } catch (std::exception& e) { cerr << "Failed at tau = " << tau << endl; cerr << e.what() << endl; pointRes.Ei = numeric_limits<double>::quiet_NaN(); pointRes.Ef = numeric_limits<double>::quiet_NaN(); pointRes.Q = numeric_limits<double>::quiet_NaN(); pointRes.p = numeric_limits<double>::quiet_NaN(); pointRes.U0 = numeric_limits<double>::quiet_NaN(); pointRes.J0 = vector<double>(L, numeric_limits<double>::quiet_NaN()); pointRes.b0 = vector<complex<double>>(L, numeric_limits<double>::quiet_NaN()); pointRes.bf = vector<complex<double>>(L, numeric_limits<double>::quiet_NaN()); pointRes.f0 = vector<vector<complex<double>>>(L, vector<complex<double>>(dim, numeric_limits<double>::quiet_NaN())); pointRes.ff = vector<vector<complex<double>>>(L, vector<complex<double>>(dim, numeric_limits<double>::quiet_NaN())); pointRes.runtime = "Failed"; } { boost::mutex::scoped_lock lock(inputs_mutex); res.push_back(pointRes); } { boost::mutex::scoped_lock lock(progress_mutex); ++progress; } } bar.wait(); { boost::mutex::scoped_lock lock(problem_mutex); // delete prob; } }
void f(barrier& b) { for (int i = 0; i < 3; i++){ b.enter(); } }