Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/fiber/include/boost/fiber/future | repos/fiber/include/boost/fiber/future/detail/task_base.hpp | // Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FIBERS_DETAIL_TASK_BASE_H
#define BOOST_FIBERS_DETAIL_TASK_BASE_H
#include <boost/config.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/fiber/detail/config.hpp>
#include <boost/fiber/future/detail/shared_state.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace detail {
template< typename R, typename ... Args >
struct task_base : public shared_state< R > {
typedef intrusive_ptr< task_base > ptr_type;
virtual ~task_base() {
}
virtual void run( Args && ... args) = 0;
virtual ptr_type reset() = 0;
};
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_FIBERS_DETAIL_TASK_BASE_H
|
0 | repos/fiber/include/boost/fiber/future | repos/fiber/include/boost/fiber/future/detail/shared_state_object.hpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FIBERS_DETAIL_SHARED_STATE_OBJECT_H
#define BOOST_FIBERS_DETAIL_SHARED_STATE_OBJECT_H
#include <memory>
#include <boost/config.hpp>
#include <boost/fiber/detail/config.hpp>
#include <boost/fiber/future/detail/shared_state.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace detail {
template< typename R, typename Allocator >
class shared_state_object : public shared_state< R > {
public:
typedef typename std::allocator_traits< Allocator >::template rebind_alloc<
shared_state_object
> allocator_type;
shared_state_object( allocator_type const& alloc) :
shared_state< R >{},
alloc_{ alloc } {
}
protected:
void deallocate_future() noexcept override final {
destroy_( alloc_, this);
}
private:
allocator_type alloc_;
static void destroy_( allocator_type const& alloc, shared_state_object * p) noexcept {
allocator_type a{ alloc };
typedef std::allocator_traits< allocator_type > traity_type;
traity_type::destroy( a, p);
traity_type::deallocate( a, p, 1);
}
};
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_FIBERS_DETAIL_SHARED_STATE_OBJECT_H
|
0 | repos/fiber | repos/fiber/performance/clock.hpp |
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef CLOCK_H
#define CLOCK_H
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <numeric>
#include <vector>
#include <boost/assert.hpp>
typedef std::chrono::steady_clock clock_type;
typedef clock_type::duration duration_type;
typedef clock_type::time_point time_point_type;
struct clock_overhead
{
std::uint64_t operator()()
{
time_point_type start( clock_type::now() );
return ( clock_type::now() - start).count();
}
};
duration_type overhead_clock()
{
std::size_t iterations( 10);
std::vector< std::uint64_t > overhead( iterations, 0);
for ( std::size_t i = 0; i < iterations; ++i)
std::generate(
overhead.begin(), overhead.end(),
clock_overhead() );
BOOST_ASSERT( overhead.begin() != overhead.end() );
return duration_type( std::accumulate( overhead.begin(), overhead.end(), 0) / iterations);
}
#endif // CLOCK_H
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_shared_detach.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/fiber/numa/pin_thread.hpp>
#include <boost/predef.h>
#include "barrier.hpp"
using allocator_type = boost::fibers::fixedsize_stack;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using lock_type = std::unique_lock< std::mutex >;
using time_point_type = clock_type::time_point;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
boost::fibers::fiber{ boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div }.detach();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
void thread( unsigned int idx, barrier * b) {
boost::fibers::numa::pin_thread( idx);
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >();
b->wait();
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >();
unsigned int n = std::thread::hardware_concurrency();
barrier b( n);
boost::fibers::numa::pin_thread( n - 1);
std::size_t size{ 1000000 };
std::size_t div{ 10 };
std::vector< std::thread > threads;
for ( unsigned int i = 1; i < n; ++i) {
threads.emplace_back( thread, i - 1, & b);
};
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
b.wait();
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/barrier.hpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BARRIER_H
#define BARRIER_H
#include <cstddef>
#include <condition_variable>
#include <mutex>
#include <boost/assert.hpp>
class barrier {
private:
std::size_t initial_;
std::size_t current_;
bool cycle_{ true };
std::mutex mtx_{};
std::condition_variable cond_{};
public:
explicit barrier( std::size_t initial) :
initial_{ initial },
current_{ initial_ } {
BOOST_ASSERT ( 0 != initial);
}
barrier( barrier const&) = delete;
barrier & operator=( barrier const&) = delete;
bool wait() {
std::unique_lock< std::mutex > lk( mtx_);
const bool cycle = cycle_;
if ( 0 == --current_) {
cycle_ = ! cycle_;
current_ = initial_;
lk.unlock(); // no pessimization
cond_.notify_all();
return true;
} else {
cond_.wait( lk, [&](){ return cycle != cycle_; });
}
return false;
}
};
#endif // BARRIER_H
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_shared_join.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/fiber/numa/pin_thread.hpp>
#include <boost/predef.h>
#include "barrier.hpp"
using allocator_type = boost::fibers::fixedsize_stack;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using lock_type = std::unique_lock< std::mutex >;
using time_point_type = clock_type::time_point;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
std::vector< boost::fibers::fiber > fibers;
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
fibers.emplace_back( boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div);
}
for ( auto & f: fibers) {
f.join();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
void thread( unsigned int idx, barrier * b) {
boost::fibers::numa::pin_thread( idx);
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >();
b->wait();
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >();
unsigned int n = std::thread::hardware_concurrency();
barrier b( n);
boost::fibers::numa::pin_thread( n - 1);
std::size_t size{ 1000000 };
std::size_t div{ 10 };
std::vector< std::thread > threads;
for ( unsigned int i = 1; i < n; ++i) {
threads.emplace_back( thread, i - 1, & b);
};
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
b.wait();
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_stealing_async.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <random>
#include <sstream>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/predef.h>
#include "barrier.hpp"
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using allocator_type = boost::fibers::fixedsize_stack;
using lock_type = std::unique_lock< std::mutex >;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
// microbenchmark
std::uint64_t skynet(allocator_type& salloc, std::uint64_t num, std::uint64_t size, std::uint64_t div) {
if ( size != 1){
size /= div;
std::vector<boost::fibers::future<std::uint64_t> > results;
results.reserve( div);
for ( std::uint64_t i = 0; i != div; ++i) {
std::uint64_t sub_num = num + i * size;
results.emplace_back(boost::fibers::async(
boost::fibers::launch::dispatch
, std::allocator_arg, salloc
, skynet
, std::ref( salloc), sub_num, size, div));
}
std::uint64_t sum = 0;
for ( auto& f : results)
sum += f.get();
return sum;
}
return num;
}
void thread( std::uint32_t thread_count) {
// thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
// count of logical ids
std::uint32_t thread_count = std::thread::hardware_concurrency();
std::size_t size{ 1000000 };
std::size_t div{ 10 };
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
std::vector< std::thread > threads;
for ( std::uint32_t i = 1 /* count main-thread */; i < thread_count; ++i) {
// spawn thread
threads.emplace_back( thread, thread_count);
}
// main-thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
time_point_type start{ clock_type::now() };
result = skynet( salloc, 0, size, div);
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_stealing_detach.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <random>
#include <sstream>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/predef.h>
#include "barrier.hpp"
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using allocator_type = boost::fibers::fixedsize_stack;
using lock_type = std::unique_lock< std::mutex >;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
boost::fibers::fiber{ boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div }.detach();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
void thread( std::uint32_t thread_count) {
// thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
// count of logical cpus
std::uint32_t thread_count = std::thread::hardware_concurrency();
std::size_t size{ 1000000 };
std::size_t div{ 10 };
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
std::vector< std::thread > threads;
for ( std::uint32_t i = 1 /* count main-thread */; i < thread_count; ++i) {
// spawn thread
threads.emplace_back( thread, thread_count);
}
// main-thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_stealing_join.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <random>
#include <sstream>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/predef.h>
#include "barrier.hpp"
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using allocator_type = boost::fibers::fixedsize_stack;
using lock_type = std::unique_lock< std::mutex >;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
std::vector< boost::fibers::fiber > fibers;
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
fibers.emplace_back( boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div);
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
for ( auto & f : fibers) {
f.join();
}
}
}
void thread( std::uint32_t thread_count) {
// thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
// count of logical cpus
std::uint32_t thread_count = std::thread::hardware_concurrency();
std::size_t size{ 1000000 };
std::size_t div{ 10 };
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
std::vector< std::thread > threads;
for ( std::uint32_t i = 1 /* count main-thread */; i < thread_count; ++i) {
// spawn thread
threads.emplace_back( thread, thread_count);
}
// main-thread registers itself at work-stealing scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( thread_count);
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_detach.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <numeric>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/predef.h>
using allocator_type = boost::fibers::fixedsize_stack;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
boost::fibers::fiber{ boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div }.detach();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
int main() {
try {
std::size_t size{ 1000000 };
std::size_t div{ 10 };
// Windows 10 and FreeBSD require a fiber stack of 8kb
// otherwise the stack gets exhausted
// stack requirements must be checked for other OS too
#if BOOST_OS_WINDOWS || BOOST_OS_BSD
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
#else
allocator_type salloc{ allocator_type::traits_type::page_size() };
#endif
std::uint64_t result{ 0 };
channel_type rc{ 2 };
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/fiber/skynet_join.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <numeric>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/predef.h>
using allocator_type = boost::fibers::fixedsize_stack;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
std::vector< boost::fibers::fiber > fibers;
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
fibers.emplace_back( boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div);
}
for ( auto & f: fibers) {
f.join();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
int main() {
try {
std::size_t size{ 1000000 };
std::size_t div{ 10 };
// Windows 10 and FreeBSD require a fiber stack of 8kb
// otherwise the stack gets exhausted
// stack requirements must be checked for other OS too
#if BOOST_OS_WINDOWS || BOOST_OS_BSD
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
#else
allocator_type salloc{ allocator_type::traits_type::page_size() };
#endif
std::uint64_t result{ 0 };
channel_type rc{ 2 };
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance/fiber | repos/fiber/performance/fiber/numa/skynet_stealing_detach.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <random>
#include <sstream>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/fiber/numa/all.hpp>
#include <boost/predef.h>
#include "../barrier.hpp"
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
using channel_type = boost::fibers::buffered_channel< std::uint64_t >;
using allocator_type = boost::fibers::fixedsize_stack;
using lock_type = std::unique_lock< std::mutex >;
static bool done = false;
static std::mutex mtx{};
static boost::fibers::condition_variable_any cnd{};
std::uint32_t hardware_concurrency( std::vector< boost::fibers::numa::node > const& topo) {
std::uint32_t cpus = 0;
for ( auto & node : topo) {
cpus += node.logical_cpus.size();
}
return cpus;
}
// microbenchmark
void skynet( allocator_type & salloc, channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
boost::fibers::fiber{ boost::fibers::launch::dispatch,
std::allocator_arg, salloc,
skynet,
std::ref( salloc), std::ref( rc), sub_num, size / div, div }.detach();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
void thread( std::uint32_t cpu_id, std::uint32_t node_id, std::vector< boost::fibers::numa::node > const& topo) {
boost::fibers::use_scheduling_algorithm< boost::fibers::numa::algo::work_stealing >( cpu_id, node_id, topo);
lock_type lk( mtx);
cnd.wait( lk, [](){ return done; });
BOOST_ASSERT( done);
}
int main() {
try {
std::vector< boost::fibers::numa::node > topo = boost::fibers::numa::topology();
auto node = topo[0];
auto main_cpu_id = * node.logical_cpus.begin();
std::size_t size{ 1000000 };
std::size_t div{ 10 };
allocator_type salloc{ 2*allocator_type::traits_type::page_size() };
std::uint64_t result{ 0 };
channel_type rc{ 2 };
std::vector< std::thread > threads;
for ( auto && node : topo) {
for ( std::uint32_t cpu_id : node.logical_cpus) {
// exclude main-thread
if ( main_cpu_id != cpu_id) {
threads.emplace_back( thread, cpu_id, node.id, std::cref( topo) );
}
}
}
boost::fibers::use_scheduling_algorithm< boost::fibers::numa::algo::work_stealing >( main_cpu_id, node.id, topo);
time_point_type start{ clock_type::now() };
skynet( salloc, rc, 0, size, div);
result = rc.value_pop();
if ( 499999500000 != result) {
throw std::runtime_error("invalid result");
}
auto duration = clock_type::now() - start;
lock_type lk( mtx);
done = true;
lk.unlock();
cnd.notify_all();
for ( std::thread & t : threads) {
t.join();
}
std::cout << "duration: " << duration.count() / 1000000 << " ms" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/thread/skynet_pthread.cpp | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <numeric>
#include <stdexcept>
#include <vector>
extern "C" {
#include <pthread.h>
#include <signal.h>
}
#include "buffered_channel.hpp"
using channel_type = buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
struct thread_args {
channel_type & c;
std::size_t num;
std::size_t size;
std::size_t div;
};
// microbenchmark
void * skynet( void * vargs) {
thread_args * args = static_cast< thread_args * >( vargs);
if ( 1 == args->size) {
args->c.push( args->num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < args->div; ++i) {
auto sub_num = args->num + i * args->size / args->div;
auto sub_size = args->size / args->div;
auto size = 8 * 1024;
pthread_attr_t tattr;
if ( 0 != ::pthread_attr_init( & tattr) ) {
std::runtime_error("pthread_attr_init() failed");
}
if ( 0 != ::pthread_attr_setstacksize( & tattr, size) ) {
std::runtime_error("pthread_attr_setstacksize() failed");
}
thread_args * targs = new thread_args{ rc, sub_num, sub_size, args->div };
pthread_t tid;
if ( 0 != ::pthread_create( & tid, & tattr, & skynet, targs) ) {
std::runtime_error("pthread_create() failed");
}
if ( 0 != ::pthread_detach( tid) ) {
std::runtime_error("pthread_detach() failed");
}
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < args->div; ++i) {
sum += rc.value_pop();
}
args->c.push( sum);
}
delete args;
return nullptr;
}
int main() {
try {
std::size_t size{ 10000 };
std::size_t div{ 10 };
std::uint64_t result{ 0 };
duration_type duration{ duration_type::zero() };
channel_type rc{ 2 };
thread_args * targs = new thread_args{ rc, 0, size, div };
time_point_type start{ clock_type::now() };
skynet( targs);
result = rc.value_pop();
duration = clock_type::now() - start;
std::cout << "Result: " << result << " in " << duration.count() / 1000000 << " ms" << std::endl;
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/thread/skynet_std.cpp | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <numeric>
#include <thread>
#include <vector>
#include "buffered_channel.hpp"
using channel_type = buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
// microbenchmark
void skynet( channel_type & c, std::size_t num, std::size_t size, std::size_t div) {
if ( 1 == size) {
c.push( num);
} else {
channel_type rc{ 16 };
for ( std::size_t i = 0; i < div; ++i) {
auto sub_num = num + i * size / div;
std::thread{ skynet, std::ref( rc), sub_num, size / div, div }.detach();
}
std::uint64_t sum{ 0 };
for ( std::size_t i = 0; i < div; ++i) {
sum += rc.value_pop();
}
c.push( sum);
}
}
int main() {
try {
std::size_t size{ 10000 };
std::size_t div{ 10 };
std::uint64_t result{ 0 };
duration_type duration{ duration_type::zero() };
channel_type rc{ 2 };
time_point_type start{ clock_type::now() };
skynet( rc, 0, size, div);
result = rc.value_pop();
duration = clock_type::now() - start;
std::cout << "Result: " << result << " in " << duration.count() / 1000000 << " ms" << std::endl;
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/performance | repos/fiber/performance/thread/buffered_channel.hpp |
// Copyright Oliver Kowalke 2016.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// based on Dmitry Vyukov's MPMC queue
// (http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue)
#ifndef BUFFERED_CHANNEL_H
#define BUFFERED_CHANNEL_H
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <type_traits>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/fiber/detail/config.hpp>
enum class channel_op_status {
success = 0,
empty,
full,
closed,
timeout
};
template< typename T >
class buffered_channel {
public:
typedef T value_type;
private:
typedef typename std::aligned_storage< sizeof( T), alignof( T) >::type storage_type;
struct alignas(cache_alignment) slot {
std::atomic< std::size_t > cycle{ 0 };
storage_type storage{};
slot() = default;
};
// procuder cacheline
alignas(cache_alignment) std::atomic< std::size_t > producer_idx_{ 0 };
// consumer cacheline
alignas(cache_alignment) std::atomic< std::size_t > consumer_idx_{ 0 };
// shared write cacheline
alignas(cache_alignment) std::atomic_bool closed_{ false };
mutable std::mutex mtx_{};
std::condition_variable not_full_cnd_{};
std::condition_variable not_empty_cnd_{};
// shared read cacheline
alignas(cache_alignment) slot * slots_{ nullptr };
std::size_t capacity_;
char pad_[cacheline_length];
std::size_t waiting_consumer_{ 0 };
bool is_full_() {
std::size_t idx{ producer_idx_.load( std::memory_order_relaxed) };
return 0 > static_cast< std::intptr_t >( slots_[idx & (capacity_ - 1)].cycle.load( std::memory_order_acquire) ) - static_cast< std::intptr_t >( idx);
}
bool is_empty_() {
std::size_t idx{ consumer_idx_.load( std::memory_order_relaxed) };
return 0 > static_cast< std::intptr_t >( slots_[idx & (capacity_ - 1)].cycle.load( std::memory_order_acquire) ) - static_cast< std::intptr_t >( idx + 1);
}
template< typename ValueType >
channel_op_status try_push_( ValueType && value) {
slot * s{ nullptr };
std::size_t idx{ producer_idx_.load( std::memory_order_relaxed) };
for (;;) {
s = & slots_[idx & (capacity_ - 1)];
std::size_t cycle{ s->cycle.load( std::memory_order_acquire) };
std::intptr_t diff{ static_cast< std::intptr_t >( cycle) - static_cast< std::intptr_t >( idx) };
if ( 0 == diff) {
if ( producer_idx_.compare_exchange_weak( idx, idx + 1, std::memory_order_relaxed) ) {
break;
}
} else if ( 0 > diff) {
return channel_op_status::full;
} else {
idx = producer_idx_.load( std::memory_order_relaxed);
}
}
::new ( static_cast< void * >( std::addressof( s->storage) ) ) value_type( std::forward< ValueType >( value) );
s->cycle.store( idx + 1, std::memory_order_release);
return channel_op_status::success;
}
channel_op_status try_value_pop_( slot *& s, std::size_t & idx) {
idx = consumer_idx_.load( std::memory_order_relaxed);
for (;;) {
s = & slots_[idx & (capacity_ - 1)];
std::size_t cycle = s->cycle.load( std::memory_order_acquire);
std::intptr_t diff{ static_cast< std::intptr_t >( cycle) - static_cast< std::intptr_t >( idx + 1) };
if ( 0 == diff) {
if ( consumer_idx_.compare_exchange_weak( idx, idx + 1, std::memory_order_relaxed) ) {
break;
}
} else if ( 0 > diff) {
return channel_op_status::empty;
} else {
idx = consumer_idx_.load( std::memory_order_relaxed);
}
}
// incrementing the slot cycle must be deferred till the value has been consumed
// slot cycle tells procuders that the cell can be re-used (store new value)
return channel_op_status::success;
}
channel_op_status try_pop_( value_type & value) {
slot * s{ nullptr };
std::size_t idx{ 0 };
channel_op_status status{ try_value_pop_( s, idx) };
if ( channel_op_status::success == status) {
value = std::move( * reinterpret_cast< value_type * >( std::addressof( s->storage) ) );
s->cycle.store( idx + capacity_, std::memory_order_release);
}
return status;
}
public:
explicit buffered_channel( std::size_t capacity) :
capacity_{ capacity } {
if ( 0 == capacity_ || 0 != ( capacity_ & (capacity_ - 1) ) ) {
throw std::runtime_error{ "boost fiber: buffer capacity is invalid" };
}
slots_ = new slot[capacity_]();
for ( std::size_t i = 0; i < capacity_; ++i) {
slots_[i].cycle.store( i, std::memory_order_relaxed);
}
}
~buffered_channel() {
close();
for (;;) {
slot * s{ nullptr };
std::size_t idx{ 0 };
if ( channel_op_status::success == try_value_pop_( s, idx) ) {
reinterpret_cast< value_type * >( std::addressof( s->storage) )->~value_type();
s->cycle.store( idx + capacity_, std::memory_order_release);
} else {
break;
}
}
delete [] slots_;
}
buffered_channel( buffered_channel const&) = delete;
buffered_channel & operator=( buffered_channel const&) = delete;
bool is_closed() const noexcept {
return closed_.load( std::memory_order_acquire);
}
void close() noexcept {
std::unique_lock< std::mutex > lk{ mtx_ };
closed_.store( true, std::memory_order_release);
not_full_cnd_.notify_all();
not_empty_cnd_.notify_all();
}
channel_op_status push( value_type const& value) {
for (;;) {
if ( is_closed() ) {
return channel_op_status::closed;
}
channel_op_status status{ try_push_( value) };
if ( channel_op_status::success == status) {
std::unique_lock< std::mutex > lk{ mtx_ };
if ( 0 < waiting_consumer_) {
not_empty_cnd_.notify_one();
}
return status;
} else if ( channel_op_status::full == status) {
std::unique_lock< std::mutex > lk{ mtx_ };
if ( is_closed() ) {
return channel_op_status::closed;
}
if ( ! is_full_() ) {
continue;
}
not_full_cnd_.wait( lk, [this]{ return is_closed() || ! is_full_(); });
} else {
BOOST_ASSERT( channel_op_status::closed == status);
return status;
}
}
}
value_type value_pop() {
for (;;) {
slot * s{ nullptr };
std::size_t idx{ 0 };
channel_op_status status{ try_value_pop_( s, idx) };
if ( channel_op_status::success == status) {
value_type value{ std::move( * reinterpret_cast< value_type * >( std::addressof( s->storage) ) ) };
s->cycle.store( idx + capacity_, std::memory_order_release);
not_full_cnd_.notify_one();
return std::move( value);
} else if ( channel_op_status::empty == status) {
std::unique_lock< std::mutex > lk{ mtx_ };
++waiting_consumer_;
if ( is_closed() ) {
throw std::runtime_error{ "boost fiber: channel is closed" };
}
if ( ! is_empty_() ) {
continue;
}
not_empty_cnd_.wait( lk, [this](){ return is_closed() || ! is_empty_(); });
--waiting_consumer_;
} else {
BOOST_ASSERT( channel_op_status::closed == status);
throw std::runtime_error{ "boost fiber: channel is closed" };
}
}
}
};
#endif // BUFFERED_CHANNEL_H
|
0 | repos/fiber/performance | repos/fiber/performance/thread/skynet_async.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// based on https://github.com/atemerev/skynet from Alexander Temerev
#include <algorithm>
#include <cassert>
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <queue>
#include <future>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <random>
#include <sstream>
#include <vector>
#include "buffered_channel.hpp"
using channel_type = buffered_channel< std::uint64_t >;
using clock_type = std::chrono::steady_clock;
using duration_type = clock_type::duration;
using time_point_type = clock_type::time_point;
// microbenchmark
std::uint64_t skynet( std::uint64_t num, std::uint64_t size, std::uint64_t div)
{
if ( size != 1){
size /= div;
std::vector<std::future<std::uint64_t> > results;
results.reserve( div);
for ( std::uint64_t i = 0; i != div; ++i) {
std::uint64_t sub_num = num + i * size;
results.emplace_back(
std::async( skynet, sub_num, size, div) );
}
std::uint64_t sum = 0;
for ( auto& f : results)
sum += f.get();
return sum;
}
return num;
}
int main() {
try {
std::size_t size{ 10000 };
std::size_t div{ 10 };
std::uint64_t result{ 0 };
duration_type duration{ duration_type::zero() };
time_point_type start{ clock_type::now() };
result = skynet( 0, size, div);
duration = clock_type::now() - start;
std::cout << "Result: " << result << " in " << duration.count() / 1000000 << " ms" << std::endl;
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/src/waker.cpp |
#include "boost/fiber/waker.hpp"
#include "boost/fiber/context.hpp"
namespace boost {
namespace fibers {
bool
waker::wake() const noexcept {
BOOST_ASSERT(epoch_ > 0);
BOOST_ASSERT(ctx_ != nullptr);
return ctx_->wake(epoch_);
}
void
wait_queue::suspend_and_wait( detail::spinlock_lock & lk, context * active_ctx) {
waker_with_hook w{ active_ctx->create_waker() };
slist_.push_back(w);
// suspend this fiber
active_ctx->suspend( lk);
BOOST_ASSERT( ! w.is_linked() );
}
bool
wait_queue::suspend_and_wait_until( detail::spinlock_lock & lk,
context * active_ctx,
std::chrono::steady_clock::time_point const& timeout_time) {
waker_with_hook w{ active_ctx->create_waker() };
slist_.push_back(w);
// suspend this fiber
if ( ! active_ctx->wait_until( timeout_time, lk, waker(w)) ) {
// relock local lk
for(;;) {
if(lk.try_lock())
break;
active_ctx->yield();
}
// remove from waiting-queue
if ( w.is_linked()) {
slist_.remove( w);
}
lk.unlock();
return false;
}
return true;
}
void
wait_queue::notify_one() {
while ( ! slist_.empty() ) {
waker & w = slist_.front();
slist_.pop_front();
if ( w.wake()) {
break;
}
}
}
void
wait_queue::notify_all() {
while ( ! slist_.empty() ) {
waker & w = slist_.front();
slist_.pop_front();
w.wake();
}
}
bool
wait_queue::empty() const {
return slist_.empty();
}
}
}
|
0 | repos/fiber | repos/fiber/src/condition_variable.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/condition_variable.hpp"
#include "boost/fiber/context.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
condition_variable_any::notify_one() noexcept {
detail::spinlock_lock lk{ wait_queue_splk_ };
wait_queue_.notify_one();
}
void
condition_variable_any::notify_all() noexcept {
detail::spinlock_lock lk{ wait_queue_splk_ };
wait_queue_.notify_all();
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/mutex.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/mutex.hpp"
#include <algorithm>
#include <functional>
#include <system_error>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#include "boost/fiber/waker.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
mutex::lock() {
while ( true) {
context * active_ctx = context::active();
// store this fiber in order to be notified later
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx == owner_) ) {
throw lock_error{
std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: a deadlock is detected" };
}
if ( nullptr == owner_) {
owner_ = active_ctx;
return;
}
wait_queue_.suspend_and_wait( lk, active_ctx);
}
}
bool
mutex::try_lock() {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx == owner_) ) {
throw lock_error{
std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: a deadlock is detected" };
}
if ( nullptr == owner_) {
owner_ = active_ctx;
}
lk.unlock();
// let other fiber release the lock
active_ctx->yield();
return active_ctx == owner_;
}
void
mutex::unlock() {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx != owner_) ) {
throw lock_error{
std::make_error_code( std::errc::operation_not_permitted),
"boost fiber: no privilege to perform the operation" };
}
owner_ = nullptr;
wait_queue_.notify_one();
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/recursive_mutex.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/recursive_mutex.hpp"
#include <algorithm>
#include <functional>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
recursive_mutex::lock() {
while ( true) {
context * active_ctx = context::active();
// store this fiber in order to be notified later
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( active_ctx == owner_) {
++count_;
return;
}
if ( nullptr == owner_) {
owner_ = active_ctx;
count_ = 1;
return;
}
wait_queue_.suspend_and_wait( lk, active_ctx);
}
}
bool
recursive_mutex::try_lock() noexcept {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( nullptr == owner_) {
owner_ = active_ctx;
count_ = 1;
} else if ( active_ctx == owner_) {
++count_;
}
lk.unlock();
// let other fiber release the lock
context::active()->yield();
return active_ctx == owner_;
}
void
recursive_mutex::unlock() {
context * active_ctx = context::active();
detail::spinlock_lock lk( wait_queue_splk_);
if ( BOOST_UNLIKELY( active_ctx != owner_) ) {
throw lock_error(
std::make_error_code( std::errc::operation_not_permitted),
"boost fiber: no privilege to perform the operation");
}
if ( 0 == --count_) {
owner_ = nullptr;
wait_queue_.notify_one();
}
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/future.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/exceptions.hpp"
namespace boost {
namespace fibers {
class future_error_category : public std::error_category {
public:
const char* name() const noexcept override {
return "fiber-future";
}
std::error_condition default_error_condition( int ev) const noexcept override {
switch ( static_cast< future_errc >( ev) ) {
case future_errc::broken_promise:
return std::error_condition{
static_cast< int >( future_errc::broken_promise),
future_category() };
case future_errc::future_already_retrieved:
return std::error_condition{
static_cast< int >( future_errc::future_already_retrieved),
future_category() };
case future_errc::promise_already_satisfied:
return std::error_condition{
static_cast< int >( future_errc::promise_already_satisfied),
future_category() };
case future_errc::no_state:
return std::error_condition{
static_cast<
int >( future_errc::no_state),
future_category() };
default:
return std::error_condition{ ev, * this };
}
}
bool equivalent( std::error_code const& code, int condition) const noexcept override {
return * this == code.category() &&
static_cast< int >( default_error_condition( code.value() ).value() ) == condition;
}
std::string message( int ev) const override {
switch ( static_cast< future_errc >( ev) ) {
case future_errc::broken_promise:
return std::string{ "The associated promise has been destructed prior "
"to the associated state becoming ready." };
case future_errc::future_already_retrieved:
return std::string{ "The future has already been retrieved from "
"the promise or packaged_task." };
case future_errc::promise_already_satisfied:
return std::string{ "The state of the promise has already been set." };
case future_errc::no_state:
return std::string{ "Operation not permitted on an object without "
"an associated state." };
}
return std::string{ "unspecified future_errc value\n" };
}
};
BOOST_FIBERS_DECL
std::error_category const& future_category() noexcept {
static fibers::future_error_category cat;
return cat;
}
}}
|
0 | repos/fiber | repos/fiber/src/recursive_timed_mutex.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/recursive_timed_mutex.hpp"
#include <algorithm>
#include <functional>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
bool
recursive_timed_mutex::try_lock_until_( std::chrono::steady_clock::time_point const& timeout_time) noexcept {
while ( true) {
if ( std::chrono::steady_clock::now() > timeout_time) {
return false;
}
context * active_ctx = context::active();
// store this fiber in order to be notified later
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( active_ctx == owner_) {
++count_;
return true;
}
if ( nullptr == owner_) {
owner_ = active_ctx;
count_ = 1;
return true;
}
if ( ! wait_queue_.suspend_and_wait_until( lk, active_ctx, timeout_time)) {
return false;
}
}
}
void
recursive_timed_mutex::lock() {
while ( true) {
context * active_ctx = context::active();
// store this fiber in order to be notified later
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( active_ctx == owner_) {
++count_;
return;
}
if ( nullptr == owner_) {
owner_ = active_ctx;
count_ = 1;
return;
}
wait_queue_.suspend_and_wait( lk, active_ctx);
}
}
bool
recursive_timed_mutex::try_lock() noexcept {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( nullptr == owner_) {
owner_ = active_ctx;
count_ = 1;
} else if ( active_ctx == owner_) {
++count_;
}
lk.unlock();
// let other fiber release the lock
active_ctx->yield();
return active_ctx == owner_;
}
void
recursive_timed_mutex::unlock() {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx != owner_) ) {
throw lock_error{
std::make_error_code( std::errc::operation_not_permitted),
"boost fiber: no privilege to perform the operation" };
}
if ( 0 == --count_) {
owner_ = nullptr;
wait_queue_.notify_one();
}
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/barrier.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/barrier.hpp"
#include <mutex>
#include <system_error>
#include "boost/fiber/exceptions.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
barrier::barrier( std::size_t initial) :
initial_{ initial },
current_{ initial_ } {
if ( BOOST_UNLIKELY( 0 == initial) ) {
throw fiber_error{ std::make_error_code( std::errc::invalid_argument),
"boost fiber: zero initial barrier count" };
}
}
bool
barrier::wait() {
std::unique_lock< mutex > lk{ mtx_ };
const std::size_t cycle = cycle_;
if ( 0 == --current_) {
++cycle_;
current_ = initial_;
lk.unlock(); // no pessimization
cond_.notify_all();
return true;
}
cond_.wait( lk, [&]{ return cycle != cycle_; });
return false;
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/properties.cpp | // Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/properties.hpp"
#include <boost/assert.hpp>
#include "boost/fiber/algo/algorithm.hpp"
#include "boost/fiber/scheduler.hpp"
#include "boost/fiber/context.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
fiber_properties::notify() noexcept {
BOOST_ASSERT( nullptr != algo_);
// Application code might change an important property for any fiber at
// any time. The fiber in question might be ready, running or waiting.
// Significantly, only a fiber which is ready but not actually running is
// in the sched_algorithm's ready queue. Don't bother the sched_algorithm
// with a change to a fiber it's not currently tracking: it will do the
// right thing next time the fiber is passed to its awakened() method.
if ( ctx_->ready_is_linked() ) {
dynamic_cast< algo::algorithm_with_properties_base * >( algo_)->
property_change_( ctx_, this);
}
}
}} // boost::fibers
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/fiber.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/fiber.hpp"
#include <system_error>
#include <boost/assert.hpp>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
fiber::start_() noexcept {
context * ctx = context::active();
ctx->attach( impl_.get() );
switch ( impl_->get_policy() ) {
case launch::post:
// push new fiber to ready-queue
// resume executing current fiber
ctx->get_scheduler()->schedule( impl_.get() );
break;
case launch::dispatch:
// resume new fiber and push current fiber
// to ready-queue
impl_->resume( ctx);
break;
default:
BOOST_ASSERT_MSG( false, "unknown launch-policy");
}
}
void
fiber::join() {
// FIXME: must fiber::join() be synchronized?
if ( BOOST_UNLIKELY( context::active()->get_id() == get_id() ) ) {
throw fiber_error{ std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: trying to join itself" };
}
if ( BOOST_UNLIKELY( ! joinable() ) ) {
throw fiber_error{ std::make_error_code( std::errc::invalid_argument),
"boost fiber: fiber not joinable" };
}
impl_->join();
impl_.reset();
}
void
fiber::detach() {
if ( BOOST_UNLIKELY( ! joinable() ) ) {
throw fiber_error{ std::make_error_code( std::errc::invalid_argument),
"boost fiber: fiber not joinable" };
}
impl_.reset();
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/context.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/context.hpp"
#include <cstdlib>
#include <mutex>
#include <new>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#include "boost/fiber/algo/round_robin.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
class main_context final : public context {
public:
main_context() noexcept :
context{ 1, type::main_context, launch::post } {
}
};
class dispatcher_context final : public context {
private:
boost::context::fiber
#if (defined(BOOST_USE_UCONTEXT)||defined(BOOST_USE_WINFIB))
run_( boost::context::fiber && c) {
std::move( c).resume();
#else
run_( boost::context::fiber &&) {
#endif
// execute scheduler::dispatch()
return get_scheduler()->dispatch();
}
public:
dispatcher_context( boost::context::preallocated const& palloc, stack_allocator_wrapper&& salloc) :
context{ 0, type::dispatcher_context, launch::post } {
c_ = boost::context::fiber{ std::allocator_arg, palloc, std::move(salloc),
std::bind( & dispatcher_context::run_, this, std::placeholders::_1) };
#if (defined(BOOST_USE_UCONTEXT)||defined(BOOST_USE_WINFIB))
c_ = std::move( c_).resume();
#endif
}
};
static intrusive_ptr< context > make_dispatcher_context(stack_allocator_wrapper&& salloc) {
auto sctx = salloc.allocate();
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( dispatcher_context) ) )
& ~ static_cast< uintptr_t >( 0xff) );
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
const std::size_t size = reinterpret_cast< uintptr_t >( storage) - reinterpret_cast< uintptr_t >( stack_bottom);
// placement new of context on top of fiber's stack
return intrusive_ptr< context >{
new ( storage) dispatcher_context{
boost::context::preallocated{ storage, size, sctx }, std::move( salloc) } };
}
// schwarz counter
struct context_initializer {
static thread_local context * active_;
static thread_local std::size_t counter_;
using default_scheduler = algo::round_robin;
template< typename ... Args >
context_initializer(Args && ... args) {
if ( 0 == counter_++) {
initialize(std::forward< Args >( args) ... );
}
}
~context_initializer() {
if ( 0 == --counter_) {
deinitialize();
}
}
void initialize()
{
initialize(new default_scheduler(), make_stack_allocator_wrapper<default_stack>());
}
void initialize(algo::algorithm::ptr_t algo, stack_allocator_wrapper&& salloc)
{
// main fiber context of this thread
context * main_ctx = new main_context{};
// scheduler of this thread
auto sched = new scheduler(algo);
// attach main context to scheduler
sched->attach_main_context( main_ctx);
// create and attach dispatcher context to scheduler
sched->attach_dispatcher_context( make_dispatcher_context(std::move(salloc)) );
// make main context to active context
active_ = main_ctx;
}
void deinitialize()
{
context * main_ctx = active_;
BOOST_ASSERT( main_ctx->is_context( type::main_context) );
scheduler * sched = main_ctx->get_scheduler();
delete sched;
delete main_ctx;
}
};
// zero-initialization
thread_local context * context_initializer::active_{ nullptr };
thread_local std::size_t context_initializer::counter_{ 0 };
bool context::initialize_thread(algo::algorithm::ptr_t algo, stack_allocator_wrapper&& salloc) noexcept
{
if (context_initializer::counter_ == 0)
{
// Initilization is not done yet, so do it now with a local variable
// context_initializer which will decrease the counter when leaving this function.
context_initializer ctx_initializer(algo, std::move(salloc));
// Now call active() to register a thread local context_initializer which will
// ensure resources are free'ed when the thread exits.
active();
return true;
}
else
{
// It's too late already to initialize the dispatcher stack allocator, still we can update
// the algo.
active()->get_scheduler()->set_algo(algo);
return false;
}
}
context *
context::active() noexcept {
// initialized the first time control passes; per thread
thread_local static context_initializer ctx_initializer;
return context_initializer::active_;
}
void
context::reset_active() noexcept {
context_initializer::active_ = nullptr;
}
context::~context() {
// protect for concurrent access
std::unique_lock< detail::spinlock > lk{ splk_ };
BOOST_ASSERT( ! ready_is_linked() );
BOOST_ASSERT( ! remote_ready_is_linked() );
BOOST_ASSERT( ! sleep_is_linked() );
if ( is_context( type::dispatcher_context) ) {
BOOST_ASSERT( nullptr == active() );
}
BOOST_ASSERT( wait_queue_.empty() );
delete properties_;
}
context::id
context::get_id() const noexcept {
return id{ const_cast< context * >( this) };
}
void
context::resume() noexcept {
context * prev = this;
// context_initializer::active_ will point to `this`
// prev will point to previous active context
std::swap( context_initializer::active_, prev);
// pass pointer to the context that resumes `this`
std::move( c_).resume_with([prev](boost::context::fiber && c){
prev->c_ = std::move( c);
return boost::context::fiber{};
});
}
void
context::resume( detail::spinlock_lock & lk) noexcept {
context * prev = this;
// context_initializer::active_ will point to `this`
// prev will point to previous active context
std::swap( context_initializer::active_, prev);
// pass pointer to the context that resumes `this`
std::move( c_).resume_with([prev,&lk](boost::context::fiber && c){
prev->c_ = std::move( c);
lk.unlock();
return boost::context::fiber{};
});
}
void
context::resume( context * ready_ctx) noexcept {
context * prev = this;
// context_initializer::active_ will point to `this`
// prev will point to previous active context
std::swap( context_initializer::active_, prev);
// pass pointer to the context that resumes `this`
std::move( c_).resume_with([prev,ready_ctx](boost::context::fiber && c){
prev->c_ = std::move( c);
context::active()->schedule( ready_ctx);
return boost::context::fiber{};
});
}
void
context::suspend() noexcept {
get_scheduler()->suspend();
}
void
context::suspend( detail::spinlock_lock & lk) noexcept {
get_scheduler()->suspend( lk);
}
void
context::join() {
// get active context
context * active_ctx = context::active();
// protect for concurrent access
std::unique_lock< detail::spinlock > lk{ splk_ };
// wait for context which is not terminated
if ( ! terminated_) {
// push active context to wait-queue, member
// of the context which has to be joined by
// the active context
wait_queue_.suspend_and_wait( lk, active_ctx);
// active context resumed
BOOST_ASSERT( context::active() == active_ctx);
}
}
void
context::yield() noexcept {
// yield active context
get_scheduler()->yield( context::active() );
}
boost::context::fiber
context::suspend_with_cc() noexcept {
context * prev = this;
// context_initializer::active_ will point to `this`
// prev will point to previous active context
std::swap( context_initializer::active_, prev);
// pass pointer to the context that resumes `this`
return std::move( c_).resume_with([prev](boost::context::fiber && c){
prev->c_ = std::move( c);
return boost::context::fiber{};
});
}
boost::context::fiber
context::terminate() noexcept {
// protect for concurrent access
std::unique_lock< detail::spinlock > lk{ splk_ };
// mark as terminated
terminated_ = true;
// notify all waiting fibers
wait_queue_.notify_all();
BOOST_ASSERT( wait_queue_.empty() );
// release fiber-specific-data
for ( fss_data_t::value_type & data : fss_data_) {
data.second.do_cleanup();
}
fss_data_.clear();
// switch to another context
return get_scheduler()->terminate( lk, this);
}
bool
context::wait_until( std::chrono::steady_clock::time_point const& tp) noexcept {
BOOST_ASSERT( nullptr != get_scheduler() );
BOOST_ASSERT( this == active() );
return get_scheduler()->wait_until( this, tp);
}
bool
context::wait_until( std::chrono::steady_clock::time_point const& tp,
detail::spinlock_lock & lk,
waker && w) noexcept {
BOOST_ASSERT( nullptr != get_scheduler() );
BOOST_ASSERT( this == active() );
return get_scheduler()->wait_until( this, tp, lk, std::move(w));
}
bool context::wake(const size_t epoch) noexcept
{
size_t expected = epoch;
bool is_last_waker = waker_epoch_.compare_exchange_strong(expected, epoch + 1, std::memory_order_acq_rel);
if ( ! is_last_waker) {
// waker_epoch_ has been incremented before, so consider this wake
// operation as outdated and do nothing
return false;
}
BOOST_ASSERT( context::active() != this);
if ( context::active()->get_scheduler() == get_scheduler()) {
get_scheduler()->schedule( this);
} else {
get_scheduler()->schedule_from_remote( this);
}
return true;
}
void
context::schedule( context * ctx) noexcept {
//BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( this != ctx);
BOOST_ASSERT( nullptr != get_scheduler() );
BOOST_ASSERT( nullptr != ctx->get_scheduler() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
// FIXME: comparing scheduler address' must be synchronized?
// what if ctx is migrated between threads
// (other scheduler assigned)
if ( scheduler_ == ctx->get_scheduler() ) {
// local
get_scheduler()->schedule( ctx);
} else {
// remote
ctx->get_scheduler()->schedule_from_remote( ctx);
}
#else
BOOST_ASSERT( get_scheduler() == ctx->get_scheduler() );
get_scheduler()->schedule( ctx);
#endif
}
void *
context::get_fss_data( void const * vp) const {
auto key = reinterpret_cast< uintptr_t >( vp);
auto i = fss_data_.find( key);
return fss_data_.end() != i ? i->second.vp : nullptr;
}
void
context::set_fss_data( void const * vp,
detail::fss_cleanup_function::ptr_t const& cleanup_fn,
void * data,
bool cleanup_existing) {
BOOST_ASSERT( cleanup_fn);
auto key = reinterpret_cast< uintptr_t >( vp);
auto i = fss_data_.find( key);
if ( fss_data_.end() != i) {
if( cleanup_existing) {
i->second.do_cleanup();
}
if ( nullptr != data) {
i->second = fss_data{ data, cleanup_fn };
} else {
fss_data_.erase( i);
}
} else {
fss_data_.insert(
std::make_pair(
key,
fss_data{ data, cleanup_fn } ) );
}
}
void
context::set_properties( fiber_properties * props) noexcept {
delete properties_;
properties_ = props;
}
bool
context::worker_is_linked() const noexcept {
return worker_hook_.is_linked();
}
bool
context::ready_is_linked() const noexcept {
return ready_hook_.is_linked();
}
bool
context::remote_ready_is_linked() const noexcept {
return remote_ready_hook_.is_linked();
}
bool
context::sleep_is_linked() const noexcept {
return sleep_hook_.is_linked();
}
bool
context::terminated_is_linked() const noexcept {
return terminated_hook_.is_linked();
}
void
context::worker_unlink() noexcept {
BOOST_ASSERT( worker_is_linked() );
worker_hook_.unlink();
}
void
context::ready_unlink() noexcept {
BOOST_ASSERT( ready_is_linked() );
ready_hook_.unlink();
}
void
context::sleep_unlink() noexcept {
BOOST_ASSERT( sleep_is_linked() );
sleep_hook_.unlink();
}
void
context::detach() noexcept {
BOOST_ASSERT( context::active() != this);
get_scheduler()->detach_worker_context( this);
}
void
context::attach( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
get_scheduler()->attach_worker_context( ctx);
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/timed_mutex.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/timed_mutex.hpp"
#include <algorithm>
#include <functional>
#include "boost/fiber/exceptions.hpp"
#include "boost/fiber/scheduler.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
bool
timed_mutex::try_lock_until_( std::chrono::steady_clock::time_point const& timeout_time) noexcept {
while ( true) {
if ( std::chrono::steady_clock::now() > timeout_time) {
return false;
}
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( nullptr == owner_) {
owner_ = active_ctx;
return true;
}
if ( ! wait_queue_.suspend_and_wait_until( lk, active_ctx, timeout_time)) {
return false;
}
}
}
void
timed_mutex::lock() {
while ( true) {
context * active_ctx = context::active();
// store this fiber in order to be notified later
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx == owner_) ) {
throw lock_error{
std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: a deadlock is detected" };
}
if ( nullptr == owner_) {
owner_ = active_ctx;
return;
}
wait_queue_.suspend_and_wait( lk, active_ctx);
}
}
bool
timed_mutex::try_lock() {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx == owner_) ) {
throw lock_error{
std::make_error_code( std::errc::resource_deadlock_would_occur),
"boost fiber: a deadlock is detected" };
}
if ( nullptr == owner_) {
owner_ = active_ctx;
}
lk.unlock();
// let other fiber release the lock
active_ctx->yield();
return active_ctx == owner_;
}
void
timed_mutex::unlock() {
context * active_ctx = context::active();
detail::spinlock_lock lk{ wait_queue_splk_ };
if ( BOOST_UNLIKELY( active_ctx != owner_) ) {
throw lock_error{
std::make_error_code( std::errc::operation_not_permitted),
"boost fiber: no privilege to perform the operation" };
}
owner_ = nullptr;
wait_queue_.notify_one();
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/src/scheduler.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/scheduler.hpp"
#include <chrono>
#include <mutex>
#include <boost/assert.hpp>
#include "boost/fiber/context.hpp"
#include "boost/fiber/exceptions.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
void
scheduler::release_terminated_() noexcept {
while ( ! terminated_queue_.empty() ) {
context * ctx = & terminated_queue_.front();
terminated_queue_.pop_front();
BOOST_ASSERT( ctx->is_context( type::worker_context) );
BOOST_ASSERT( ! ctx->is_context( type::pinned_context) );
BOOST_ASSERT( this == ctx->get_scheduler() );
BOOST_ASSERT( ctx->is_resumable() );
BOOST_ASSERT( ! ctx->worker_is_linked() );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ctx->wait_queue_.empty() );
BOOST_ASSERT( ctx->terminated_);
// if last reference, e.g. fiber::join() or fiber::detach()
// have been already called, this will call ~context(),
// the context is automatically removeid from worker-queue
intrusive_ptr_release( ctx);
}
}
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
void
scheduler::remote_ready2ready_() noexcept {
remote_ready_queue_type tmp;
detail::spinlock_lock lk{ remote_ready_splk_ };
remote_ready_queue_.swap( tmp);
lk.unlock();
// get context from remote ready-queue
while ( ! tmp.empty() ) {
context * ctx = & tmp.front();
tmp.pop_front();
// store context in local queues
schedule( ctx);
}
}
#endif
void
scheduler::sleep2ready_() noexcept {
// move context which the deadline has reached
// to ready-queue
// sleep-queue is sorted (ascending)
std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
sleep_queue_type::iterator e = sleep_queue_.end();
for ( sleep_queue_type::iterator i = sleep_queue_.begin(); i != e;) {
context * ctx = & ( * i);
// dispatcher context must never be pushed to sleep-queue
BOOST_ASSERT( ! ctx->is_context( type::dispatcher_context) );
BOOST_ASSERT( main_ctx_ == ctx || ctx->worker_is_linked() );
BOOST_ASSERT( ! ctx->ready_is_linked() );
// remote_ready_hook_ can be linked in that point in case when the ctx
// has been signaled concurrently when sleep2ready_ is called. In that
// case sleep_waker_.wake() is just no-op, because sleep_waker_ is
// outdated
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// set fiber to state_ready if deadline was reached
if ( ctx->tp_ <= now) {
// remove context from sleep-queue
i = sleep_queue_.erase( i);
// reset sleep-tp
ctx->tp_ = (std::chrono::steady_clock::time_point::max)();
ctx->sleep_waker_.wake();
} else {
break; // first context with now < deadline
}
}
}
scheduler::scheduler(algo::algorithm::ptr_t algo) noexcept :
algo_{algo} {
}
scheduler::~scheduler() {
BOOST_ASSERT( nullptr != main_ctx_);
BOOST_ASSERT( nullptr != dispatcher_ctx_.get() );
BOOST_ASSERT( context::active() == main_ctx_);
// signal dispatcher-context termination
shutdown_ = true;
// resume pending fibers
// by resuming dispatcher-context
context::active()->suspend();
// no context' in worker-queue
BOOST_ASSERT( worker_queue_.empty() );
BOOST_ASSERT( terminated_queue_.empty() );
BOOST_ASSERT( sleep_queue_.empty() );
// set active context to nullptr
context::reset_active();
// deallocate dispatcher-context
BOOST_ASSERT( ! dispatcher_ctx_->ready_is_linked() );
dispatcher_ctx_.reset();
// set main-context to nullptr
main_ctx_ = nullptr;
}
boost::context::fiber
scheduler::dispatch() noexcept {
BOOST_ASSERT( context::active() == dispatcher_ctx_);
for (;;) {
if ( shutdown_) {
// notify sched-algorithm about termination
algo_->notify();
if ( worker_queue_.empty() ) {
break;
}
}
// release terminated context'
release_terminated_();
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
// get context' from remote ready-queue
remote_ready2ready_();
#endif
// get sleeping context'
// must be called after remote_ready2ready_()
sleep2ready_();
// get next ready context
context * ctx = algo_->pick_next();
if ( nullptr != ctx) {
BOOST_ASSERT( ctx->is_resumable() );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// push dispatcher-context to ready-queue
// so that ready-queue never becomes empty
ctx->resume( dispatcher_ctx_.get() );
BOOST_ASSERT( context::active() == dispatcher_ctx_.get() );
} else {
// no ready context, wait till signaled
// set deadline to highest value
std::chrono::steady_clock::time_point suspend_time =
(std::chrono::steady_clock::time_point::max)();
// get lowest deadline from sleep-queue
sleep_queue_type::iterator i = sleep_queue_.begin();
if ( sleep_queue_.end() != i) {
suspend_time = i->tp_;
}
// no ready context, wait till signaled
algo_->suspend_until( suspend_time);
}
}
// release termianted context'
release_terminated_();
// return to main-context
return main_ctx_->suspend_with_cc();
}
void
scheduler::schedule( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// remove context ctx from sleep-queue
// (might happen if blocked in timed_mutex::try_lock_until())
if ( ctx->sleep_is_linked() ) {
// unlink it from sleep-queue
ctx->sleep_unlink();
}
// push new context to ready-queue
algo_->awakened( ctx);
}
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
void
scheduler::schedule_from_remote( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
// another thread might signal the main-context of this thread
BOOST_ASSERT( ! ctx->is_context( type::dispatcher_context) );
BOOST_ASSERT( this == ctx->get_scheduler() );
BOOST_ASSERT( ! ctx->ready_is_linked() );
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// protect for concurrent access
detail::spinlock_lock lk{ remote_ready_splk_ };
BOOST_ASSERT( ! shutdown_);
BOOST_ASSERT( nullptr != main_ctx_);
BOOST_ASSERT( nullptr != dispatcher_ctx_.get() );
// push new context to remote ready-queue
ctx->remote_ready_link( remote_ready_queue_);
lk.unlock();
// notify scheduler
algo_->notify();
}
#endif
boost::context::fiber
scheduler::terminate( detail::spinlock_lock & lk, context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( context::active() == ctx);
BOOST_ASSERT( this == ctx->get_scheduler() );
BOOST_ASSERT( ctx->is_context( type::worker_context) );
BOOST_ASSERT( ! ctx->is_context( type::pinned_context) );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
BOOST_ASSERT( ctx->wait_queue_.empty() );
// store the terminated fiber in the terminated-queue
// the dispatcher-context will call
ctx->terminated_link( terminated_queue_);
// remove from the worker-queue
ctx->worker_unlink();
// release lock
lk.unlock();
// resume another fiber
return algo_->pick_next()->suspend_with_cc();
}
void
scheduler::yield( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( context::active() == ctx);
BOOST_ASSERT( ctx->is_context( type::worker_context) || ctx->is_context( type::main_context) );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// resume another fiber
algo_->pick_next()->resume( ctx);
}
bool
scheduler::wait_until( context * ctx,
std::chrono::steady_clock::time_point const& sleep_tp) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( context::active() == ctx);
BOOST_ASSERT( ctx->is_context( type::worker_context) || ctx->is_context( type::main_context) );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
ctx->sleep_waker_ = ctx->create_waker();
ctx->tp_ = sleep_tp;
ctx->sleep_link( sleep_queue_);
// resume another context
algo_->pick_next()->resume();
// context has been resumed
// check if deadline has reached
return std::chrono::steady_clock::now() < sleep_tp;
}
bool
scheduler::wait_until( context * ctx,
std::chrono::steady_clock::time_point const& sleep_tp,
detail::spinlock_lock & lk,
waker && w) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( context::active() == ctx);
BOOST_ASSERT( ctx->is_context( type::worker_context) || ctx->is_context( type::main_context) );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
// push active context to sleep-queue
ctx->sleep_waker_ = std::move( w);
ctx->tp_ = sleep_tp;
ctx->sleep_link( sleep_queue_);
// resume another context
algo_->pick_next()->resume( lk);
// context has been resumed
// check if deadline has reached
return std::chrono::steady_clock::now() < sleep_tp;
}
void
scheduler::suspend() noexcept {
// resume another context
algo_->pick_next()->resume();
}
void
scheduler::suspend( detail::spinlock_lock & lk) noexcept {
// resume another context
algo_->pick_next()->resume( lk);
}
bool
scheduler::has_ready_fibers() const noexcept {
return algo_->has_ready_fibers();
}
void
scheduler::set_algo( algo::algorithm::ptr_t algo) noexcept {
// move remaining context in current scheduler to new one
while ( algo_->has_ready_fibers() ) {
algo->awakened( algo_->pick_next() );
}
algo_ = std::move( algo);
}
void
scheduler::attach_main_context( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
// main-context represents the execution context created
// by the system, e.g. main()- or thread-context
// should not be in worker-queue
main_ctx_ = ctx;
main_ctx_->scheduler_ = this;
}
void
scheduler::attach_dispatcher_context( intrusive_ptr< context > ctx) noexcept {
BOOST_ASSERT( ctx);
// dispatcher context has to handle
// - remote ready context'
// - sleeping context'
// - extern event-loops
// - suspending the thread if ready-queue is empty (waiting on external event)
// should not be in worker-queue
dispatcher_ctx_.swap( ctx);
// add dispatcher-context to ready-queue
// so it is the first element in the ready-queue
// if the main context tries to suspend the first time
// the dispatcher-context is resumed and
// scheduler::dispatch() is executed
dispatcher_ctx_->scheduler_ = this;
algo_->awakened( dispatcher_ctx_.get() );
}
void
scheduler::attach_worker_context( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( nullptr == ctx->get_scheduler() );
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
BOOST_ASSERT( ! ctx->worker_is_linked() );
ctx->worker_link( worker_queue_);
ctx->scheduler_ = this;
// an attached context must belong at least to worker-queue
}
void
scheduler::detach_worker_context( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( ! ctx->ready_is_linked() );
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
BOOST_ASSERT( ! ctx->remote_ready_is_linked() );
#endif
BOOST_ASSERT( ! ctx->sleep_is_linked() );
BOOST_ASSERT( ! ctx->terminated_is_linked() );
BOOST_ASSERT( ctx->worker_is_linked() );
BOOST_ASSERT( ! ctx->is_context( type::pinned_context) );
ctx->worker_unlink();
BOOST_ASSERT( ! ctx->worker_is_linked() );
ctx->scheduler_ = nullptr;
// a detached context must not belong to any queue
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/algo/round_robin.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/algo/round_robin.hpp"
#include <boost/assert.hpp>
#include <boost/context/detail/prefetch.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace algo {
void
round_robin::awakened( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( ! ctx->ready_is_linked() );
BOOST_ASSERT( ctx->is_resumable() );
ctx->ready_link( rqueue_);
}
context *
round_robin::pick_next() noexcept {
context * victim = nullptr;
if ( ! rqueue_.empty() ) {
victim = & rqueue_.front();
rqueue_.pop_front();
boost::context::detail::prefetch_range( victim, sizeof( context) );
BOOST_ASSERT( nullptr != victim);
BOOST_ASSERT( ! victim->ready_is_linked() );
BOOST_ASSERT( victim->is_resumable() );
}
return victim;
}
bool
round_robin::has_ready_fibers() const noexcept {
return ! rqueue_.empty();
}
void
round_robin::suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept {
if ( (std::chrono::steady_clock::time_point::max)() == time_point) {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait( lk, [&](){ return flag_; });
flag_ = false;
} else {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait_until( lk, time_point, [&](){ return flag_; });
flag_ = false;
}
}
void
round_robin::notify() noexcept {
std::unique_lock< std::mutex > lk{ mtx_ };
flag_ = true;
lk.unlock();
cnd_.notify_all();
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/algo/shared_work.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/algo/shared_work.hpp"
#include <boost/assert.hpp>
#include "boost/fiber/type.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace algo {
//[awakened_ws
void
shared_work::awakened( context * ctx) noexcept {
if ( ctx->is_context( type::pinned_context) ) { /*<
recognize when we're passed this thread's main fiber (or an
implicit library helper fiber): never put those on the shared
queue
>*/
lqueue_.push_back( * ctx);
} else {
ctx->detach();
std::unique_lock< std::mutex > lk{ rqueue_mtx_ }; /*<
worker fiber, enqueue on shared queue
>*/
rqueue_.push_back( ctx);
}
}
//]
//[pick_next_ws
context *
shared_work::pick_next() noexcept {
context * ctx = nullptr;
std::unique_lock< std::mutex > lk{ rqueue_mtx_ };
if ( ! rqueue_.empty() ) { /*<
pop an item from the ready queue
>*/
ctx = rqueue_.front();
rqueue_.pop_front();
lk.unlock();
BOOST_ASSERT( nullptr != ctx);
context::active()->attach( ctx); /*<
attach context to current scheduler via the active fiber
of this thread
>*/
} else {
lk.unlock();
if ( ! lqueue_.empty() ) { /*<
nothing in the ready queue, return main or dispatcher fiber
>*/
ctx = & lqueue_.front();
lqueue_.pop_front();
}
}
return ctx;
}
//]
void
shared_work::suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept {
if ( suspend_) {
if ( (std::chrono::steady_clock::time_point::max)() == time_point) {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait( lk, [this](){ return flag_; });
flag_ = false;
} else {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait_until( lk, time_point, [this](){ return flag_; });
flag_ = false;
}
}
}
void
shared_work::notify() noexcept {
if ( suspend_) {
std::unique_lock< std::mutex > lk{ mtx_ };
flag_ = true;
lk.unlock();
cnd_.notify_all();
}
}
shared_work::rqueue_type shared_work::rqueue_{};
std::mutex shared_work::rqueue_mtx_{};
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/algo/algorithm.cpp |
// Copyright Oliver Kowalke / Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/algo/algorithm.hpp"
#include "boost/fiber/context.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace algo {
//static
fiber_properties *
algorithm_with_properties_base::get_properties( context * ctx) noexcept {
return ctx->get_properties();
}
//static
void
algorithm_with_properties_base::set_properties( context * ctx, fiber_properties * props) noexcept {
ctx->set_properties( props);
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/algo/work_stealing.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include "boost/fiber/algo/work_stealing.hpp"
#include <random>
#include <boost/assert.hpp>
#include <boost/context/detail/prefetch.hpp>
#include "boost/fiber/detail/thread_barrier.hpp"
#include "boost/fiber/type.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace algo {
std::atomic< std::uint32_t > work_stealing::counter_{ 0 };
std::vector< intrusive_ptr< work_stealing > > work_stealing::schedulers_{};
void
work_stealing::init_( std::uint32_t thread_count,
std::vector< intrusive_ptr< work_stealing > > & schedulers) {
// resize array of schedulers to thread_count, initilized with nullptr
std::vector< intrusive_ptr< work_stealing > >{ thread_count, nullptr }.swap( schedulers);
}
work_stealing::work_stealing( std::uint32_t thread_count, bool suspend) :
id_{ counter_++ },
thread_count_{ thread_count },
suspend_{ suspend } {
static boost::fibers::detail::thread_barrier b{ thread_count };
// initialize the array of schedulers
static std::once_flag flag;
std::call_once( flag, & work_stealing::init_, thread_count_, std::ref( schedulers_) );
// register pointer of this scheduler
schedulers_[id_] = this;
b.wait();
}
void
work_stealing::awakened( context * ctx) noexcept {
if ( ! ctx->is_context( type::pinned_context) ) {
ctx->detach();
}
rqueue_.push( ctx);
}
context *
work_stealing::pick_next() noexcept {
context * victim = rqueue_.pop();
if ( nullptr != victim) {
boost::context::detail::prefetch_range( victim, sizeof( context) );
if ( ! victim->is_context( type::pinned_context) ) {
context::active()->attach( victim);
}
} else {
std::uint32_t id = 0;
std::size_t count = 0, size = schedulers_.size();
static thread_local std::minstd_rand generator{ std::random_device{}() };
std::uniform_int_distribution< std::uint32_t > distribution{
0, static_cast< std::uint32_t >( thread_count_ - 1) };
do {
do {
++count;
// random selection of one logical cpu
// that belongs to the local NUMA node
id = distribution( generator);
// prevent stealing from own scheduler
} while ( id == id_);
// steal context from other scheduler
victim = schedulers_[id]->steal();
} while ( nullptr == victim && count < size);
if ( nullptr != victim) {
boost::context::detail::prefetch_range( victim, sizeof( context) );
BOOST_ASSERT( ! victim->is_context( type::pinned_context) );
context::active()->attach( victim);
}
}
return victim;
}
void
work_stealing::suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept {
if ( suspend_) {
if ( (std::chrono::steady_clock::time_point::max)() == time_point) {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait( lk, [this](){ return flag_; });
flag_ = false;
} else {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait_until( lk, time_point, [this](){ return flag_; });
flag_ = false;
}
}
}
void
work_stealing::notify() noexcept {
if ( suspend_) {
std::unique_lock< std::mutex > lk{ mtx_ };
flag_ = true;
lk.unlock();
cnd_.notify_all();
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/numa/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
#include <system_error>
#include "boost/fiber/exceptions.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
#if BOOST_COMP_CLANG || \
BOOST_COMP_GNUC || \
BOOST_COMP_INTEL || \
BOOST_COMP_MSVC
# pragma message "topology() not supported"
#endif
BOOST_FIBERS_DECL
std::vector< node > topology() {
throw fiber_error{
std::make_error_code( std::errc::function_not_supported),
"boost fiber: topology() not supported" };
return std::vector< node >{};
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src | repos/fiber/src/numa/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
#include <system_error>
#include "boost/fiber/exceptions.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
#if BOOST_COMP_CLANG || \
BOOST_COMP_GNUC || \
BOOST_COMP_INTEL || \
BOOST_COMP_MSVC
# pragma message "pin_thread() not supported"
#endif
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t) {
throw fiber_error{
std::make_error_code( std::errc::function_not_supported),
"boost fiber: pin_thread() not supported" };
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
throw fiber_error{
std::make_error_code( std::errc::function_not_supported),
"boost fiber: pin_thread() not supported" };
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/linux/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
#include <exception>
#include <map>
#include <regex>
#include <set>
#include <string>
#include <utility>
#include <boost/algorithm/string.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/format.hpp>
#include "boost/fiber/exceptions.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if !defined(BOOST_NO_CXX11_HDR_REGEX)
namespace al = boost::algorithm;
namespace fs = boost::filesystem;
namespace {
class directory_iterator {
private:
fs::directory_iterator i_;
fs::directory_iterator e_;
std::regex exp_;
std::pair< std::uint32_t, fs::path > idx_;
bool eval_( fs::directory_entry const& entry) {
std::string filename( entry.path().filename().string() );
std::smatch what;
if ( ! std::regex_search( filename, what, exp_) ) {
return false;
}
idx_ = std::make_pair( std::stoul( what[1].str() ), entry.path() );
return true;
}
public:
typedef std::input_iterator_tag iterator_category;
typedef const std::pair< std::uint32_t, fs::path > value_type;
typedef std::ptrdiff_t difference_type;
typedef value_type * pointer;
typedef value_type & reference;
directory_iterator() :
i_(), e_(), exp_(), idx_() {
}
directory_iterator( fs::path const& dir, std::string const& exp) :
i_( dir), e_(), exp_( exp), idx_() {
while ( i_ != e_ && ! eval_( * i_) ) {
++i_;
}
}
bool operator==( directory_iterator const& other) const {
return i_ == other.i_;
}
bool operator!=( directory_iterator const& other) const {
return i_ != other.i_;
}
directory_iterator & operator++() {
do {
++i_;
} while ( i_ != e_ && ! eval_( * i_) );
return * this;
}
directory_iterator operator++( int) {
directory_iterator tmp( * this);
++*this;
return tmp;
}
reference operator*() const {
return idx_;
}
pointer operator->() const {
return & idx_;
}
};
std::set< std::uint32_t > ids_from_line( std::string const& content) {
std::set< std::uint32_t > ids;
std::vector< std::string > v1;
al::split( v1, content, al::is_any_of(",") );
for ( std::string entry : v1) {
al::trim( entry);
std::vector< std::string > v2;
al::split( v2, entry, al::is_any_of("-") );
BOOST_ASSERT( ! v2.empty() );
if ( 1 == v2.size() ) {
// only one ID
ids.insert( std::stoul( v2[0]) );
} else {
// range of IDs
std::uint32_t first = std::stoul( * v2.begin() );
std::uint32_t last = std::stoul( * v2.rbegin() );
for ( std::uint32_t i = first; i <= last; ++i) {
ids.insert( i);
}
}
}
return ids;
}
std::vector< std::uint32_t > distance_from_line( std::string const& content) {
std::vector< std::uint32_t > distance;
std::vector< std::string > v1;
al::split( v1, content, al::is_any_of(" ") );
for ( std::string entry : v1) {
al::trim( entry);
BOOST_ASSERT( ! entry.empty() );
distance.push_back( std::stoul( entry) );
}
return distance;
}
}
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
std::vector< node > topology() {
std::vector< node > topo;
// 1. parse list of CPUs which are online
fs::ifstream fs_online{ fs::path("/sys/devices/system/cpu/online") };
std::string content;
std::getline( fs_online, content);
std::set< std::uint32_t > cpus = ids_from_line( content);
if ( cpus.empty() ) {
// parsing cpus failed
return topo;
}
std::map< std::uint32_t, node > map;
// iterate list of logical cpus
for ( std::uint32_t cpu_id : cpus) {
fs::path cpu_path{
boost::str(
boost::format("/sys/devices/system/cpu/cpu%d/") % cpu_id) };
BOOST_ASSERT( fs::exists( cpu_path) );
// 2. to witch NUMA node the CPU belongs to
directory_iterator e;
for ( directory_iterator i{ cpu_path, "^node([0-9]+)$" };
i != e; ++i) {
std::uint32_t node_id = i->first;
map[node_id].id = node_id;
map[node_id].logical_cpus.insert( cpu_id);
// assigned to only one NUMA node
break;
}
}
if ( map.empty() ) {
// maybe /sys/devices/system/cpu/cpu[0-9]/node[0-9] was not defined
// put all CPUs to NUMA node 0
map[0].id = 0;
for ( std::uint32_t cpu_id : cpus) {
map[0].logical_cpus.insert( cpu_id);
}
}
for ( auto entry : map) {
// NUMA-node distance
fs::path distance_path{
boost::str(
boost::format("/sys/devices/system/node/node%d/distance") % entry.second.id) };
if ( fs::exists( distance_path) ) {
fs::ifstream fs_distance{ distance_path };
std::string content;
std::getline( fs_distance, content);
entry.second.distance = distance_from_line( content);
topo.push_back( entry.second);
} else {
// fake NUMA distance
entry.second.distance.push_back( 10);
topo.push_back( entry.second);
}
}
return topo;
}
}}}
#else
namespace boost {
namespace fibers {
namespace numa {
#if BOOST_COMP_CLANG || \
BOOST_COMP_GNUC || \
BOOST_COMP_INTEL || \
BOOST_COMP_MSVC
# pragma message "topology() not supported without <regex>"
#endif
BOOST_FIBERS_DECL
std::vector< node > topology() {
throw fiber_error{
std::make_error_code( std::errc::function_not_supported),
"boost fiber: topology() not supported without <regex>" };
return std::vector< node >{};
}
}}}
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/linux/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <pthread.h>
#include <sched.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
pin_thread( cpuid, ::pthread_self() );
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
cpu_set_t set;
CPU_ZERO( & set);
CPU_SET( cpuid, & set);
int err = 0;
if ( BOOST_UNLIKELY( 0 != ( err = ::pthread_setaffinity_np( h, sizeof( set), & set) ) ) ) {
throw std::system_error(
std::error_code( err, std::system_category() ),
"pthread_setaffinity_np() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/algo/work_stealing.cpp |
// Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include "boost/fiber/numa/algo/work_stealing.hpp"
#include <cmath>
#include <random>
#include <boost/assert.hpp>
#include <boost/context/detail/prefetch.hpp>
#include "boost/fiber/detail/thread_barrier.hpp"
#include "boost/fiber/type.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
namespace algo {
std::vector< intrusive_ptr< work_stealing > > work_stealing::schedulers_{};
std::vector< std::uint32_t > get_local_cpus( std::uint32_t node_id, std::vector< boost::fibers::numa::node > const& topo) {
for ( auto & node : topo) {
if ( node_id == node.id) {
// store IDs of logical cpus that belong to this local NUMA node
return std::vector< std::uint32_t >{ node.logical_cpus.begin(), node.logical_cpus.end() };
}
}
return std::vector< std::uint32_t >{};
}
std::vector< std::uint32_t > get_remote_cpus( std::uint32_t node_id, std::vector< boost::fibers::numa::node > const& topo) {
std::vector< std::uint32_t > remote_cpus;
for ( auto & node : topo) {
if ( node_id != node.id) {
// store IDs of logical cpus that belong to a remote NUMA node
// no ordering regarding to the NUMA distance
remote_cpus.insert( remote_cpus.end(), node.logical_cpus.begin(), node.logical_cpus.end() );
}
}
return remote_cpus;
}
void
work_stealing::init_( std::vector< boost::fibers::numa::node > const& topo,
std::vector< intrusive_ptr< work_stealing > > & schedulers) {
std::uint32_t max_cpu_id = 0;
for ( auto & node : topo) {
max_cpu_id = (std::max)( max_cpu_id, * node.logical_cpus.rbegin() );
}
// resize array of schedulers to max. CPU ID, initilized with nullptr
// CPU ID acts as the index in the scheduler array
// if a logical cpus is offline, schedulers_ will contain a nullptr
// logical cpus index starts at `0` -> add 1
std::vector< intrusive_ptr< work_stealing > >{ max_cpu_id + 1, nullptr }.swap( schedulers);
}
work_stealing::work_stealing(
std::uint32_t cpu_id,
std::uint32_t node_id,
std::vector< boost::fibers::numa::node > const& topo,
bool suspend) :
cpu_id_{ cpu_id },
local_cpus_{ get_local_cpus( node_id, topo) },
remote_cpus_{ get_remote_cpus( node_id, topo) },
suspend_{ suspend } {
// pin current thread to logical cpu
boost::fibers::numa::pin_thread( cpu_id_);
// calculate thread count
std::size_t thread_count = 0;
for ( auto & node : topo) {
thread_count += node.logical_cpus.size();
}
static boost::fibers::detail::thread_barrier b{ thread_count };
// initialize the array of schedulers
static std::once_flag flag;
std::call_once( flag, & work_stealing::init_, topo, std::ref( schedulers_) );
// register pointer of this scheduler
schedulers_[cpu_id_] = this;
b.wait();
}
void
work_stealing::awakened( context * ctx) noexcept {
if ( ! ctx->is_context( type::pinned_context) ) {
ctx->detach();
}
rqueue_.push( ctx);
}
context *
work_stealing::pick_next() noexcept {
context * victim = rqueue_.pop();
if ( nullptr != victim) {
boost::context::detail::prefetch_range( victim, sizeof( context) );
if ( ! victim->is_context( type::pinned_context) ) {
context::active()->attach( victim);
}
} else {
std::uint32_t cpu_id = 0;
std::size_t count = 0, size = local_cpus_.size();
static thread_local std::minstd_rand generator{ std::random_device{}() };
std::uniform_int_distribution< std::uint32_t > local_distribution{
0, static_cast< std::uint32_t >( local_cpus_.size() - 1) };
std::uniform_int_distribution< std::uint32_t > remote_distribution{
0, static_cast< std::uint32_t >( remote_cpus_.size() - 1) };
do {
do {
++count;
// random selection of one logical cpu
// that belongs to the local NUMA node
cpu_id = local_cpus_[local_distribution( generator)];
// prevent stealing from own scheduler
} while ( cpu_id == cpu_id_);
// steal context from other scheduler
// schedulers_[cpu_id] should never contain a nullptr
BOOST_ASSERT( nullptr != schedulers_[cpu_id]);
victim = schedulers_[cpu_id]->steal();
} while ( nullptr == victim && count < size);
if ( nullptr != victim) {
boost::context::detail::prefetch_range( victim, sizeof( context) );
BOOST_ASSERT( ! victim->is_context( type::pinned_context) );
context::active()->attach( victim);
} else if ( ! remote_cpus_.empty() ) {
cpu_id = 0;
count = 0;
size = remote_cpus_.size();
do {
++count;
// random selection of one logical cpu
// that belongs to a remote NUMA node
cpu_id = remote_cpus_[remote_distribution( generator)];
// remote cpu ID should never be equal to local cpu ID
BOOST_ASSERT( cpu_id != cpu_id_);
// schedulers_[cpu_id] should never contain a nullptr
BOOST_ASSERT( nullptr != schedulers_[cpu_id]);
// steal context from other scheduler
victim = schedulers_[cpu_id]->steal();
} while ( nullptr == victim && count < size);
if ( nullptr != victim) {
boost::context::detail::prefetch_range( victim, sizeof( context) );
BOOST_ASSERT( ! victim->is_context( type::pinned_context) );
// move memory from remote NUMA-node to
// memory of local NUMA-node
context::active()->attach( victim);
}
}
}
return victim;
}
void
work_stealing::suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept {
if ( suspend_) {
if ( (std::chrono::steady_clock::time_point::max)() == time_point) {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait( lk, [this](){ return flag_; });
flag_ = false;
} else {
std::unique_lock< std::mutex > lk{ mtx_ };
cnd_.wait_until( lk, time_point, [this](){ return flag_; });
flag_ = false;
}
}
}
void
work_stealing::notify() noexcept {
if ( suspend_) {
std::unique_lock< std::mutex > lk{ mtx_ };
flag_ = true;
lk.unlock();
cnd_.notify_all();
}
}
}}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/windows/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
extern "C" {
#include <windows.h>
}
#include <map>
#include <set>
#include <system_error>
#include <vector>
#include <boost/assert.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace {
class procinfo_iterator {
private:
using SLPI = SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;
SLPI * buffer_{ nullptr };
SLPI * procinfo_{ nullptr };
DWORD length_{ 0 };
public:
procinfo_iterator() = default;
procinfo_iterator( LOGICAL_PROCESSOR_RELATIONSHIP relship) {
if ( ::GetLogicalProcessorInformationEx( relship, nullptr, & length_) ) {
return;
}
if ( BOOST_UNLIKELY( ERROR_INSUFFICIENT_BUFFER != ::GetLastError() ) ) {
throw std::system_error{
std::error_code{ static_cast< int >( ::GetLastError() ), std::system_category() },
"::GetLogicalProcessorInformation() failed" };
}
buffer_ = reinterpret_cast< SLPI * >( LocalAlloc( LMEM_FIXED, length_) );
if ( BOOST_UNLIKELY( nullptr == buffer_) ) {
throw std::bad_alloc();
}
if ( BOOST_UNLIKELY( ! ::GetLogicalProcessorInformationEx( relship, buffer_, & length_) ) ) {
throw std::system_error{
std::error_code{ static_cast< int >( ::GetLastError() ), std::system_category() },
"::GetLogicalProcessorInformation() failed" };
}
procinfo_ = buffer_;
}
procinfo_iterator & operator++() noexcept {
if ( nullptr != procinfo_) {
length_ -= procinfo_->Size;
if ( 0 != length_) {
procinfo_ = reinterpret_cast< SLPI * >( reinterpret_cast< BYTE * >( procinfo_) + procinfo_->Size);
} else {
LocalFree( buffer_);
buffer_ = nullptr;
procinfo_ = nullptr;
}
}
return * this;
}
procinfo_iterator operator++( int) {
procinfo_iterator tmp( * this);
operator++();
return tmp;
}
SLPI * operator->() noexcept {
return procinfo_;
}
bool operator==( procinfo_iterator const& other) const noexcept {
return other.buffer_ == buffer_ && other.procinfo_ == procinfo_ && other.length_ == length_;
}
bool operator!=( procinfo_iterator const& other) const noexcept {
return ! ( * this == other);
}
};
std::set< std::uint32_t > compute_cpu_set( WORD group_id, KAFFINITY mask) {
std::set< std::uint32_t > cpus;
for ( int i = 0; i < sizeof( mask) * 8; ++i) {
if ( mask & ( static_cast< KAFFINITY >( 1) << i) ) {
cpus.insert( static_cast< std::uint32_t >( 64 * group_id + i) );
}
}
return cpus;
}
}
namespace boost {
namespace fibers {
namespace numa {
std::vector< node > topology() {
std::vector< node > topo;
procinfo_iterator e;
for ( procinfo_iterator i{ RelationNumaNode }; i != e; ++i) {
node n;
n.id = static_cast< std::uint32_t >( i->NumaNode.NodeNumber);
auto cpus = compute_cpu_set( i->NumaNode.GroupMask.Group, i->NumaNode.GroupMask.Mask);
for ( auto cpu_id : cpus) {
n.logical_cpus.insert( static_cast< std::uint32_t >( cpu_id) );
}
topo.push_back( n);
}
// fake NUMA distance
std::size_t size = topo.size();
for ( auto & n : topo) {
for ( std::size_t i = 0; i < size; ++i) {
n.distance.push_back( n.id == i ? 10 : 20);
}
}
return topo;
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/windows/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <windows.h>
}
#include <cstring>
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
#ifdef __MINGW32__
// Workaround for bug in mingw-w64: https://sourceforge.net/p/mingw-w64/bugs/908
pin_thread( cpuid, reinterpret_cast<std::thread::native_handle_type>(::GetCurrentThread()) );
#else
pin_thread( cpuid, ::GetCurrentThread() );
#endif
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
GROUP_AFFINITY affinity;
std::memset( & affinity, 0, sizeof( affinity) );
// compute processor group
// a group contains max 64 logical CPUs
affinity.Group = static_cast< WORD >(cpuid / 64);
// compute the ID of the logical CPU in the group
uint32_t id = cpuid % 64;
// set the bit mask of the logical CPU
affinity.Mask = static_cast< KAFFINITY >( 1) << id;
#ifdef __MINGW32__
// Workaround for bug in mingw-w64: https://sourceforge.net/p/mingw-w64/bugs/908
if ( BOOST_UNLIKELY( 0 == ::SetThreadGroupAffinity( reinterpret_cast<HANDLE>(h), & affinity, nullptr) ) ) {
#else
if ( BOOST_UNLIKELY( 0 == ::SetThreadGroupAffinity( h, & affinity, nullptr) ) ) {
#endif
throw std::system_error(
std::error_code( ::GetLastError(), std::system_category() ),
"::SetThreadiGroupAffinity() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/solaris/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
extern "C" {
#include <errno.h>
#include <sys/lgrp_user.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace {
void explore( std::vector< boost::fibers::numa::node > & topo, lgrp_cookie_t cookie, lgrp_id_t node) {
int size = ::lgrp_cpus( cookie, node, nullptr, 0, LGRP_CONTENT_HIERARCHY);
if ( -1 == size) {
return;
}
// is node a NUMA Node?
if ( 0 < ::lgrp_mem_size( cookie, node, LGRP_MEM_SZ_INSTALLED, LGRP_CONTENT_DIRECT) ) {
std::vector< processorid_t > cpus;
cpus.resize( size);
::lgrp_cpus( cookie, node, cpus.data(), size, LGRP_CONTENT_HIERARCHY);
boost::fibers::numa::node n;
n.id = static_cast< std::uint32_t >( node);
for ( auto cpu_id : cpus) {
n.logical_cpus.insert( static_cast< std::uint32_t >( cpu_id) );
}
topo.push_back( n);
}
size = ::lgrp_children( cookie, node, nullptr, 0);
std::vector< lgrp_id_t > nodes;
nodes.resize( size);
::lgrp_children( cookie, node, nodes.data(), size);
for ( auto node : nodes) {
explore( topo, cookie, node);
}
}
}
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
std::vector< node > topology() {
std::vector< node > topo;
lgrp_cookie_t cookie = ::lgrp_init( LGRP_VIEW_OS);
if ( BOOST_UNLIKELY( LGRP_COOKIE_NONE == cookie) ) {
throw std::system_error{
std::error_code{ errno, std::system_category() },
"lprp_init() failed" };
}
lgrp_id_t root = ::lgrp_root( cookie);
explore( topo, cookie, root);
::lgrp_fini( cookie);
// fake NUMA distance
std::size_t size = topo.size();
for ( auto & n : topo) {
for ( std::size_t i = 0; i < size; ++i) {
n.distance.push_back( n.id == i ? 10 : 20);
}
}
return topo;
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/solaris/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <errno.h>
#include <sys/types.h>
#include <sys/processor.h>
#include <sys/procset.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
pin_thread( cpuid, P_MYID);
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
if ( BOOST_UNLIKELY( -1 == ::processor_bind( P_LWPID,
h,
static_cast< processorid_t >( cpuid),
0) ) ) {
throw std::system_error(
std::error_code( errno, std::system_category() ),
"processor_bind() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/hpux/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
extern "C" {
#include <errno.h>
#include <sys/mpctl.h>
#include <sys/types.h>
#include <types.h>
}
#include <map>
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
std::vector< node > topology() {
std::vector< node > topo;
// HP/UX has NUMA enabled
if ( 1 == ::sysconf( _SC_CCNUMA_SUPPORT) ) {
std::map< std::uint32_t, node > map;
// enumerate CPU sets
int cpu_id = ::mpctl( MPC_GETFIRSTSPU_SYS, 0, 0);
while ( -1 != cpu_id) {
int node_id = ::mpctl( MPC_SPUTOLDOM, cpu_id, 0);
if ( BOOST_UNLIKELY( -1 == node_id) ) {
throw std::system_errors{
std::error_codes{ errno, std::system_category() },
"mpctl() failed" };
}
map[id].id = static_cast< std::uint32_t >( node_id);
map[id].logical_cpus.insert( static_cast< std::uint32_t >( cpu_id) );
cpu_id = ::mpctl( MPC_GETNEXTSPU_SYS, cpu_id, 0);
}
for ( auto entry : map) {
topo.push_back( entry.second);
}
}
// fake NUMA distance
std::size_t size = topo.size();
for ( auto & n : topo) {
for ( std::size_t i = 0; i < size; ++i) {
n.distance.push_back( n.id == i ? 10 : 20);
}
}
return topo;
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/hpux/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <sys/pthread.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
pin_thread( cpuid, PTHREAD_SELFTID_NP);
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
pthread_spu_t spu;
int err = ::pthread_processor_bind_np( PTHREAD_BIND_FORCED_NP,
& spu,
static_cast< pthread_spu_t >( cpuid),
h);
if ( BOOST_UNLIKELY( 0 != err) )
throw std::system_error(
std::error_code( err, std::system_category() ),
"pthread_processor_bind_np() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/aix/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
extern "C" {
#include <errno.h>
#include <sys/rset.h>
#include <sys/types.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace {
void explore( int sdl, std::vector< boost::fibers::numa::node > & topo) {
rsethandle_t rset = ::rs_alloc( RS_PARTITION);
rsethandle_t rad = ::rs_alloc( RS_EMPTY);
int maxnodes = ::rs_numrads( rset, sdl, 0);
if ( BOOST_UNLIKELY( -1 == maxnodes) ) {
throw std::system_error{
std::error_code{ errno, std::system_category() },
"rs_numrads() failed" };
}
for ( int node_id = 0; node_id < maxnodes; ++node_id) {
if ( ::rs_getrad( rset, rad, sdl, node_id, 0) ) {
continue;
}
if ( ! ::rs_getinfo( rad, R_NUMPROCS, 0) ) {
continue;
}
boost::fibers::numa::node n;
n.id = static_cast< std::uint32_t >( node_id);
int maxcpus = ::rs_getinfo( rad, R_MAXPROCS, 0);
for ( int cpu_id = 0; cpu_id < maxcpus; ++cpu_id) {
if ( ::rs_op( RS_TESTRESOURCE, rad, nullptr, R_PROCS, cpu_id) ) {
n.logical_cpus.insert( static_cast< std::uint32_t >( cpu_id) );
}
}
topo.push_back( n);
}
::rs_free( rset);
::rs_free( rad);
}
}
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
std::vector< node > topology() {
std::vector< node > topo;
int maxlevel = ::rs_getinfo( nullptr, R_MAXSDL, 0);
for ( int i = 0; i <= maxlevel; ++i) {
if ( i == ::rs_getinfo( nullptr, R_MCMSDL, 0) ) {
explore( i, topo);
break;
}
}
// fake NUMA distance
std::size_t size = topo.size();
for ( auto & n : topo) {
for ( std::size_t i = 0; i < size; ++i) {
n.distance.push_back( n.id == i ? 10 : 20);
}
}
return topo;
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/aix/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <sys/errno.h>
#include <sys/processor.h>
#include <sys/thread.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
pin_thread( cpuid, ::thread_self() );
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
if ( BOOST_UNLIKELY( -1 == ::bindprocessor( BINDTHREAD, h, static_cast< cpu_t >( cpuid) ) ) ) {
throw std::system_error(
std::error_code( errno, std::system_category() ),
"bindprocessor() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/freebsd/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/topology.hpp"
extern "C" {
#include <errno.h>
#include <sys/param.h>
#include <sys/cpuset.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
std::vector< node > topology() {
std::vector< node > topo;
cpuset_t mask;
CPU_ZERO( & mask);
if ( BOOST_UNLIKELY( 0 != ::cpuset_getaffinity( CPU_LEVEL_WHICH, CPU_WHICH_CPUSET, -1, sizeof( mask), & mask) ) ) {
throw std::system_error{
std::error_code{ errno, std::system_category() },
"::cpuset_getaffinity() failed" };
}
node n;
n.id = 0; // FreeBSD does not support NUMA
for ( int cpu_id = 0; cpu_id < CPU_SETSIZE; ++cpu_id) {
if ( CPU_ISSET( cpu_id, & mask) ) {
n.logical_cpus.insert( static_cast< std::uint32_t >( cpu_id) );
}
}
topo.push_back( n);
// fake NUMA distance
std::size_t size = topo.size();
for ( auto & n : topo) {
for ( std::size_t i = 0; i < size; ++i) {
n.distance.push_back( n.id == i ? 10 : 20);
}
}
return topo;
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber/src/numa | repos/fiber/src/numa/freebsd/pin_thread.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "boost/fiber/numa/pin_thread.hpp"
extern "C" {
#include <pthread.h>
#include <pthread_np.h>
}
#include <system_error>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace numa {
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid) {
pin_thread( cpuid, ::pthread_self() );
}
BOOST_FIBERS_DECL
void pin_thread( std::uint32_t cpuid, std::thread::native_handle_type h) {
cpuset_t set;
CPU_ZERO( & set);
CPU_SET( cpuid, & set);
int err = 0;
if ( BOOST_UNLIKELY( 0 != ( err = ::pthread_setaffinity_np( h, sizeof( set), & set) ) ) ) {
throw std::system_error(
std::error_code( err, std::system_category() ),
"pthread_setaffinity_np() failed");
}
}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
|
0 | repos/fiber | repos/fiber/examples/adapt_nonblocking.cpp | // Copyright Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/fiber/all.hpp>
#include <iostream>
#include <sstream>
#include <exception>
#include <string>
#include <algorithm> // std::min()
#include <errno.h> // EWOULDBLOCK
#include <cassert>
#include <cstdio>
/*****************************************************************************
* example nonblocking API
*****************************************************************************/
//[NonblockingAPI
class NonblockingAPI {
public:
NonblockingAPI();
// nonblocking operation: may return EWOULDBLOCK
int read( std::string & data, std::size_t desired);
/*= ...*/
//<-
// for simulating a real nonblocking API
void set_data( std::string const& data, std::size_t chunksize);
void inject_error( int ec);
private:
std::string data_;
int injected_;
unsigned tries_;
std::size_t chunksize_;
//->
};
//]
/*****************************************************************************
* fake NonblockingAPI implementation... pay no attention to the little man
* behind the curtain...
*****************************************************************************/
NonblockingAPI::NonblockingAPI() :
injected_( 0),
tries_( 0),
chunksize_( 9999) {
}
void NonblockingAPI::set_data( std::string const& data, std::size_t chunksize) {
data_ = data;
chunksize_ = chunksize;
// This delimits the start of a new test. Reset state.
injected_ = 0;
tries_ = 0;
}
void NonblockingAPI::inject_error( int ec) {
injected_ = ec;
}
int NonblockingAPI::read( std::string & data, std::size_t desired) {
// in case of error
data.clear();
if ( injected_) {
// copy injected_ because we're about to reset it
auto injected( injected_);
injected_ = 0;
// after an error situation, restart success count
tries_ = 0;
return injected;
}
if ( ++tries_ < 5) {
// no injected error, but the resource isn't yet ready
return EWOULDBLOCK;
}
// tell caller there's nothing left
if ( data_.empty() ) {
return EOF;
}
// okay, finally have some data
// but return minimum of desired and chunksize_
std::size_t size( ( std::min)( desired, chunksize_) );
data = data_.substr( 0, size);
// strip off what we just returned
data_ = data_.substr( size);
// reset I/O retries count for next time
tries_ = 0;
// success
return 0;
}
/*****************************************************************************
* adapters
*****************************************************************************/
//[nonblocking_read_chunk
// guaranteed not to return EWOULDBLOCK
int read_chunk( NonblockingAPI & api, std::string & data, std::size_t desired) {
int error;
while ( EWOULDBLOCK == ( error = api.read( data, desired) ) ) {
// not ready yet -- try again on the next iteration of the
// application's main loop
boost::this_fiber::yield();
}
return error;
}
//]
//[nonblocking_read_desired
// keep reading until desired length, EOF or error
// may return both partial data and nonzero error
int read_desired( NonblockingAPI & api, std::string & data, std::size_t desired) {
// we're going to accumulate results into 'data'
data.clear();
std::string chunk;
int error = 0;
while ( data.length() < desired &&
( error = read_chunk( api, chunk, desired - data.length() ) ) == 0) {
data.append( chunk);
}
return error;
}
//]
//[nonblocking_IncompleteRead
// exception class augmented with both partially-read data and errorcode
class IncompleteRead : public std::runtime_error {
public:
IncompleteRead( std::string const& what, std::string const& partial, int ec) :
std::runtime_error( what),
partial_( partial),
ec_( ec) {
}
std::string get_partial() const {
return partial_;
}
int get_errorcode() const {
return ec_;
}
private:
std::string partial_;
int ec_;
};
//]
//[nonblocking_read
// read all desired data or throw IncompleteRead
std::string read( NonblockingAPI & api, std::size_t desired) {
std::string data;
int ec( read_desired( api, data, desired) );
// for present purposes, EOF isn't a failure
if ( 0 == ec || EOF == ec) {
return data;
}
// oh oh, partial read
std::ostringstream msg;
msg << "NonblockingAPI::read() error " << ec << " after "
<< data.length() << " of " << desired << " characters";
throw IncompleteRead( msg.str(), data, ec);
}
//]
int main( int argc, char *argv[]) {
NonblockingAPI api;
const std::string sample_data("abcdefghijklmnopqrstuvwxyz");
// Try just reading directly from NonblockingAPI
api.set_data( sample_data, 5);
std::string data;
int ec = api.read( data, 13);
// whoops, underlying resource not ready
assert(ec == EWOULDBLOCK);
assert(data.empty());
// successful read()
api.set_data( sample_data, 5);
data = read( api, 13);
assert(data == "abcdefghijklm");
// read() with error
api.set_data( sample_data, 5);
// don't accidentally pick either EOF or EWOULDBLOCK
assert(EOF != 1);
assert(EWOULDBLOCK != 1);
api.inject_error(1);
int thrown = 0;
try {
data = read( api, 13);
} catch ( IncompleteRead const& e) {
thrown = e.get_errorcode();
}
assert(thrown == 1);
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/work_sharing.cpp | // Copyright Nat Goodspeed + Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <sstream>
#include <string>
#include <thread>
#include <boost/assert.hpp>
#include <boost/fiber/all.hpp>
#include <boost/fiber/detail/thread_barrier.hpp>
static std::size_t fiber_count{ 0 };
static std::mutex mtx_count{};
static boost::fibers::condition_variable_any cnd_count{};
typedef std::unique_lock< std::mutex > lock_type;
/*****************************************************************************
* example fiber function
*****************************************************************************/
//[fiber_fn_ws
void whatevah( char me) {
try {
std::thread::id my_thread = std::this_thread::get_id(); /*< get ID of initial thread >*/
{
std::ostringstream buffer;
buffer << "fiber " << me << " started on thread " << my_thread << '\n';
std::cout << buffer.str() << std::flush;
}
for ( unsigned i = 0; i < 10; ++i) { /*< loop ten times >*/
boost::this_fiber::yield(); /*< yield to other fibers >*/
std::thread::id new_thread = std::this_thread::get_id(); /*< get ID of current thread >*/
if ( new_thread != my_thread) { /*< test if fiber was migrated to another thread >*/
my_thread = new_thread;
std::ostringstream buffer;
buffer << "fiber " << me << " switched to thread " << my_thread << '\n';
std::cout << buffer.str() << std::flush;
}
}
} catch ( ... ) {
}
lock_type lk( mtx_count);
if ( 0 == --fiber_count) { /*< Decrement fiber counter for each completed fiber. >*/
lk.unlock();
cnd_count.notify_all(); /*< Notify all fibers waiting on `cnd_count`. >*/
}
}
//]
/*****************************************************************************
* example thread function
*****************************************************************************/
//[thread_fn_ws
void thread( boost::fibers::detail::thread_barrier * b) {
std::ostringstream buffer;
buffer << "thread started " << std::this_thread::get_id() << std::endl;
std::cout << buffer.str() << std::flush;
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >(); /*<
Install the scheduling algorithm `boost::fibers::algo::shared_work` in order to
join the work sharing.
>*/
b->wait(); /*< sync with other threads: allow them to start processing >*/
lock_type lk( mtx_count);
cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /*<
Suspend main fiber and resume worker fibers in the meanwhile.
Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
if all worker fibers are complete.
>*/
BOOST_ASSERT( 0 == fiber_count);
}
//]
/*****************************************************************************
* main()
*****************************************************************************/
int main( int argc, char *argv[]) {
std::cout << "main thread started " << std::this_thread::get_id() << std::endl;
//[main_ws
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >(); /*<
Install the scheduling algorithm `boost::fibers::algo::shared_work` in the main thread
too, so each new fiber gets launched into the shared pool.
>*/
for ( char c : std::string("abcdefghijklmnopqrstuvwxyz")) { /*<
Launch a number of worker fibers; each worker fiber picks up a character
that is passed as parameter to fiber-function `whatevah`.
Each worker fiber gets detached.
>*/
boost::fibers::fiber([c](){ whatevah( c); }).detach();
++fiber_count; /*< Increment fiber counter for each new fiber. >*/
}
boost::fibers::detail::thread_barrier b( 4);
std::thread threads[] = { /*<
Launch a couple of threads that join the work sharing.
>*/
std::thread( thread, & b),
std::thread( thread, & b),
std::thread( thread, & b)
};
b.wait(); /*< sync with other threads: allow them to start processing >*/
{
lock_type/*< `lock_type` is typedef'ed as __unique_lock__< [@http://en.cppreference.com/w/cpp/thread/mutex `std::mutex`] > >*/ lk( mtx_count);
cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /*<
Suspend main fiber and resume worker fibers in the meanwhile.
Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
if all worker fibers are complete.
>*/
} /*<
Releasing lock of mtx_count is required before joining the threads, otherwise
the other threads would be blocked inside condition_variable::wait() and
would never return (deadlock).
>*/
BOOST_ASSERT( 0 == fiber_count);
for ( std::thread & t : threads) { /*< wait for threads to terminate >*/
t.join();
}
//]
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/adapt_method_calls.cpp | // Copyright Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/fiber/all.hpp>
#include <memory> // std::shared_ptr
#include <thread>
#include <chrono>
#include <iostream>
#include <sstream>
#include <exception>
#include <cassert>
/*****************************************************************************
* example async API
*****************************************************************************/
// introduce class-scope typedef
struct AsyncAPIBase {
// error callback accepts an int error code; 0 == success
typedef int errorcode;
};
//[Response
// every async operation receives a subclass instance of this abstract base
// class through which to communicate its result
struct Response {
typedef std::shared_ptr< Response > ptr;
// called if the operation succeeds
virtual void success( std::string const& data) = 0;
// called if the operation fails
virtual void error( AsyncAPIBase::errorcode ec) = 0;
};
//]
// the actual async API
class AsyncAPI: public AsyncAPIBase {
public:
// constructor acquires some resource that can be read
AsyncAPI( std::string const& data);
//[method_init_read
// derive Response subclass, instantiate, pass Response::ptr
void init_read( Response::ptr);
//]
// ... other operations ...
void inject_error( errorcode ec);
private:
std::string data_;
errorcode injected_;
};
/*****************************************************************************
* fake AsyncAPI implementation... pay no attention to the little man behind
* the curtain...
*****************************************************************************/
AsyncAPI::AsyncAPI( std::string const& data) :
data_( data),
injected_( 0) {
}
void AsyncAPI::inject_error( errorcode ec) {
injected_ = ec;
}
void AsyncAPI::init_read( Response::ptr response) {
// make a local copy of injected_
errorcode injected( injected_);
// reset it synchronously with caller
injected_ = 0;
// local copy of data_ so we can capture in lambda
std::string data( data_);
// Simulate an asynchronous I/O operation by launching a detached thread
// that sleeps a bit before calling either completion method.
std::thread( [injected, response, data](){
std::this_thread::sleep_for( std::chrono::milliseconds(100) );
if ( ! injected) {
// no error, call success()
response->success( data);
} else {
// injected error, call error()
response->error( injected);
}
}).detach();
}
/*****************************************************************************
* adapters
*****************************************************************************/
// helper function
std::runtime_error make_exception( std::string const& desc, AsyncAPI::errorcode);
//[PromiseResponse
class PromiseResponse: public Response {
public:
// called if the operation succeeds
virtual void success( std::string const& data) {
promise_.set_value( data);
}
// called if the operation fails
virtual void error( AsyncAPIBase::errorcode ec) {
promise_.set_exception(
std::make_exception_ptr(
make_exception("read", ec) ) );
}
boost::fibers::future< std::string > get_future() {
return promise_.get_future();
}
private:
boost::fibers::promise< std::string > promise_;
};
//]
//[method_read
std::string read( AsyncAPI & api) {
// Because init_read() requires a shared_ptr, we must allocate our
// ResponsePromise on the heap, even though we know its lifespan.
auto promisep( std::make_shared< PromiseResponse >() );
boost::fibers::future< std::string > future( promisep->get_future() );
// Both 'promisep' and 'future' will survive until our lambda has been
// called.
api.init_read( promisep);
return future.get();
}
//]
/*****************************************************************************
* helpers
*****************************************************************************/
std::runtime_error make_exception( std::string const& desc, AsyncAPI::errorcode ec) {
std::ostringstream buffer;
buffer << "Error in AsyncAPI::" << desc << "(): " << ec;
return std::runtime_error( buffer.str() );
}
/*****************************************************************************
* driving logic
*****************************************************************************/
int main(int argc, char *argv[]) {
// prime AsyncAPI with some data
AsyncAPI api("abcd");
// successful read(): retrieve it
std::string data( read( api) );
assert(data == "abcd");
// read() with error
std::string thrown;
api.inject_error(1);
try {
data = read( api);
} catch ( std::exception const& e) {
thrown = e.what();
}
assert(thrown == make_exception("read", 1).what() );
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/segmented_stack.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <thread>
#include <boost/assert.hpp>
#include <boost/fiber/all.hpp>
int count = 384;
#ifdef BOOST_MSVC //MS VisualStudio
__declspec(noinline) void access( char *buf);
#else // GCC
void access( char *buf) __attribute__ ((noinline));
#endif
void access( char *buf)
{
buf[0] = '\0';
}
void bar( int i)
{
char buf[4 * 1024];
if ( i > 0)
{
access( buf);
std::cout << i << ". iteration" << std::endl;
bar( i - 1);
}
}
void foo()
{
bar( count);
boost::this_fiber::yield();
}
void thread_fn()
{
{
boost::fibers::fiber f(
#if defined(BOOST_USE_SEGMENTED_STACKS)
std::allocator_arg,
boost::fibers::segmented_stack(
boost::fibers::segmented_stack::traits_type::default_size() ),
#endif
foo);
f.join();
}
}
int main( int argc, char * argv[])
{
#if defined(BOOST_USE_SEGMENTED_STACKS)
std::cout << "using segmented_stack stacks: allocates " << count << " * 4kB == " << 4 * count << "kB on stack, ";
std::cout << "initial stack size = " << boost::fibers::segmented_stack::traits_type::default_size() / 1024 << "kB" << std::endl;
std::cout << "application should not fail" << std::endl;
#else
std::cout << "using standard stacks: allocates " << count << " * 4kB == " << 4 * count << "kB on stack, ";
std::cout << "initial stack size = " << boost::fibers::fixedsize_stack::traits_type::default_size() / 1024 << "kB" << std::endl;
std::cout << "application might fail" << std::endl;
#endif
std::thread( thread_fn).join();
std::cout << "done." << std::endl;
return 0;
}
|
0 | repos/fiber | repos/fiber/examples/priority.cpp | // Copyright Nat Goodspeed 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <algorithm> // std::find_if()
#include <boost/fiber/all.hpp>
#include <boost/fiber/scheduler.hpp>
class Verbose {
public:
Verbose( std::string const& d, std::string const& s="stop") :
desc( d),
stop( s) {
std::cout << desc << " start" << std::endl;
}
~Verbose() {
std::cout << desc << ' ' << stop << std::endl;
}
Verbose( Verbose const&) = delete;
Verbose & operator=( Verbose const&) = delete;
private:
std::string desc;
std::string stop;
};
//[priority_props
class priority_props : public boost::fibers::fiber_properties {
public:
priority_props( boost::fibers::context * ctx):
fiber_properties( ctx), /*< Your subclass constructor must accept a
[^[class_link context]*] and pass it to
the `fiber_properties` constructor. >*/
priority_( 0) {
}
int get_priority() const {
return priority_; /*< Provide read access methods at your own discretion. >*/
}
// Call this method to alter priority, because we must notify
// priority_scheduler of any change.
void set_priority( int p) { /*<
It's important to call `notify()` on any
change in a property that can affect the
scheduler's behavior. Therefore, such
modifications should only be performed
through an access method. >*/
// Of course, it's only worth reshuffling the queue and all if we're
// actually changing the priority.
if ( p != priority_) {
priority_ = p;
notify();
}
}
// The fiber name of course is solely for purposes of this example
// program; it has nothing to do with implementing scheduler priority.
// This is a public data member -- not requiring set/get access methods --
// because we need not inform the scheduler of any change.
std::string name; /*< A property that does not affect the scheduler does
not need access methods. >*/
private:
int priority_;
};
//]
//[priority_scheduler
class priority_scheduler :
public boost::fibers::algo::algorithm_with_properties< priority_props > {
private:
typedef boost::fibers::scheduler::ready_queue_type/*< See [link ready_queue_t]. >*/ rqueue_t;
rqueue_t rqueue_;
std::mutex mtx_{};
std::condition_variable cnd_{};
bool flag_{ false };
public:
priority_scheduler() :
rqueue_() {
}
// For a subclass of algorithm_with_properties<>, it's important to
// override the correct awakened() overload.
/*<< You must override the [member_link algorithm_with_properties..awakened]
method. This is how your scheduler receives notification of a
fiber that has become ready to run. >>*/
virtual void awakened( boost::fibers::context * ctx, priority_props & props) noexcept {
int ctx_priority = props.get_priority(); /*< `props` is the instance of
priority_props associated
with the passed fiber `ctx`. >*/
// With this scheduler, fibers with higher priority values are
// preferred over fibers with lower priority values. But fibers with
// equal priority values are processed in round-robin fashion. So when
// we're handed a new context*, put it at the end of the fibers
// with that same priority. In other words: search for the first fiber
// in the queue with LOWER priority, and insert before that one.
rqueue_t::iterator i( std::find_if( rqueue_.begin(), rqueue_.end(),
[ctx_priority,this]( boost::fibers::context & c)
{ return properties( &c ).get_priority() < ctx_priority; }));
// Now, whether or not we found a fiber with lower priority,
// insert this new fiber here.
rqueue_.insert( i, * ctx);
//<-
std::cout << "awakened(" << props.name << "): ";
describe_ready_queue();
//->
}
/*<< You must override the [member_link algorithm_with_properties..pick_next]
method. This is how your scheduler actually advises the fiber manager
of the next fiber to run. >>*/
virtual boost::fibers::context * pick_next() noexcept {
// if ready queue is empty, just tell caller
if ( rqueue_.empty() ) {
return nullptr;
}
boost::fibers::context * ctx( & rqueue_.front() );
rqueue_.pop_front();
//<-
std::cout << "pick_next() resuming " << properties( ctx).name << ": ";
describe_ready_queue();
//->
return ctx;
}
/*<< You must override [member_link algorithm_with_properties..has_ready_fibers]
to inform the fiber manager of the state of your ready queue. >>*/
virtual bool has_ready_fibers() const noexcept {
return ! rqueue_.empty();
}
/*<< Overriding [member_link algorithm_with_properties..property_change]
is optional. This override handles the case in which the running
fiber changes the priority of another ready fiber: a fiber already in
our queue. In that case, move the updated fiber within the queue. >>*/
virtual void property_change( boost::fibers::context * ctx, priority_props & props) noexcept {
// Although our priority_props class defines multiple properties, only
// one of them (priority) actually calls notify() when changed. The
// point of a property_change() override is to reshuffle the ready
// queue according to the updated priority value.
//<-
std::cout << "property_change(" << props.name << '(' << props.get_priority()
<< ")): ";
//->
// 'ctx' might not be in our queue at all, if caller is changing the
// priority of (say) the running fiber. If it's not there, no need to
// move it: we'll handle it next time it hits awakened().
if ( ! ctx->ready_is_linked()) { /*<
Your `property_change()` override must be able to
handle the case in which the passed `ctx` is not in
your ready queue. It might be running, or it might be
blocked. >*/
//<-
// hopefully user will distinguish this case by noticing that
// the fiber with which we were called does not appear in the
// ready queue at all
describe_ready_queue();
//->
return;
}
// Found ctx: unlink it
ctx->ready_unlink();
// Here we know that ctx was in our ready queue, but we've unlinked
// it. We happen to have a method that will (re-)add a context* to the
// right place in the ready queue.
awakened( ctx, props);
}
//<-
void describe_ready_queue() {
if ( rqueue_.empty() ) {
std::cout << "[empty]";
} else {
const char * delim = "";
for ( boost::fibers::context & ctx : rqueue_) {
priority_props & props( properties( & ctx) );
std::cout << delim << props.name << '(' << props.get_priority() << ')';
delim = ", ";
}
}
std::cout << std::endl;
}
//->
void suspend_until( std::chrono::steady_clock::time_point const& time_point) noexcept {
if ( (std::chrono::steady_clock::time_point::max)() == time_point) {
std::unique_lock< std::mutex > lk( mtx_);
cnd_.wait( lk, [this](){ return flag_; });
flag_ = false;
} else {
std::unique_lock< std::mutex > lk( mtx_);
cnd_.wait_until( lk, time_point, [this](){ return flag_; });
flag_ = false;
}
}
void notify() noexcept {
std::unique_lock< std::mutex > lk( mtx_);
flag_ = true;
lk.unlock();
cnd_.notify_all();
}
};
//]
//[launch
template< typename Fn >
boost::fibers::fiber launch( Fn && func, std::string const& name, int priority) {
boost::fibers::fiber fiber( func);
priority_props & props( fiber.properties< priority_props >() );
props.name = name;
props.set_priority( priority);
return fiber;
}
//]
void yield_fn() {
std::string name( boost::this_fiber::properties< priority_props >().name);
Verbose v( std::string("fiber ") + name);
for ( int i = 0; i < 3; ++i) {
std::cout << "fiber " << name << " yielding" << std::endl;
boost::this_fiber::yield();
}
}
void barrier_fn( boost::fibers::barrier & barrier) {
std::string name( boost::this_fiber::properties< priority_props >().name);
Verbose v( std::string("fiber ") + name);
std::cout << "fiber " << name << " waiting on barrier" << std::endl;
barrier.wait();
std::cout << "fiber " << name << " yielding" << std::endl;
boost::this_fiber::yield();
}
//[change_fn
void change_fn( boost::fibers::fiber & other,
int other_priority,
boost::fibers::barrier& barrier) {
std::string name( boost::this_fiber::properties< priority_props >().name);
Verbose v( std::string("fiber ") + name);
//<-
std::cout << "fiber " << name << " waiting on barrier" << std::endl;
//->
barrier.wait();
// We assume a couple things about 'other':
// - that it was also waiting on the same barrier
// - that it has lower priority than this fiber.
// If both are true, 'other' is now ready to run but is sitting in
// priority_scheduler's ready queue. Change its priority.
priority_props & other_props(
other.properties< priority_props >() );
//<-
std::cout << "fiber " << name << " changing priority of " << other_props.name
<< " to " << other_priority << std::endl;
//->
other_props.set_priority( other_priority);
}
//]
//[main
int main( int argc, char *argv[]) {
// make sure we use our priority_scheduler rather than default round_robin
boost::fibers::use_scheduling_algorithm< priority_scheduler >();
/*= ...*/
/*=}*/
//]
Verbose v("main()");
// for clarity
std::cout << "main() setting name" << std::endl;
//[main_name
boost::this_fiber::properties< priority_props >().name = "main";
//]
std::cout << "main() running tests" << std::endl;
{
Verbose v("high-priority first", "stop\n");
// verify that high-priority fiber always gets scheduled first
boost::fibers::fiber low( launch( yield_fn, "low", 1) );
boost::fibers::fiber med( launch( yield_fn, "medium", 2) );
boost::fibers::fiber hi( launch( yield_fn, "high", 3) );
std::cout << "main: high.join()" << std::endl;
hi.join();
std::cout << "main: medium.join()" << std::endl;
med.join();
std::cout << "main: low.join()" << std::endl;
low.join();
}
{
Verbose v("same priority round-robin", "stop\n");
// fibers of same priority are scheduled in round-robin order
boost::fibers::fiber a( launch( yield_fn, "a", 0) );
boost::fibers::fiber b( launch( yield_fn, "b", 0) );
boost::fibers::fiber c( launch( yield_fn, "c", 0) );
std::cout << "main: a.join()" << std::endl;
a.join();
std::cout << "main: b.join()" << std::endl;
b.join();
std::cout << "main: c.join()" << std::endl;
c.join();
}
{
Verbose v("barrier wakes up all", "stop\n");
// using a barrier wakes up all waiting fibers at the same time
boost::fibers::barrier barrier( 3);
boost::fibers::fiber low( launch( [&barrier](){ barrier_fn( barrier); }, "low", 1) );
boost::fibers::fiber med( launch( [&barrier](){ barrier_fn( barrier); }, "medium", 2) );
boost::fibers::fiber hi( launch( [&barrier](){ barrier_fn( barrier); }, "high", 3) );
std::cout << "main: low.join()" << std::endl;
low.join();
std::cout << "main: medium.join()" << std::endl;
med.join();
std::cout << "main: high.join()" << std::endl;
hi.join();
}
{
Verbose v("change priority", "stop\n");
// change priority of a fiber in priority_scheduler's ready queue
boost::fibers::barrier barrier( 3);
boost::fibers::fiber c( launch( [&barrier](){ barrier_fn( barrier); }, "c", 1) );
boost::fibers::fiber a( launch( [&c,&barrier]() { change_fn( c, 3, barrier); }, "a", 3) );
boost::fibers::fiber b( launch( [&barrier](){ barrier_fn( barrier); }, "b", 2) );
std::cout << "main: a.join()" << std::endl;
std::cout << "main: a.join()" << std::endl;
a.join();
std::cout << "main: b.join()" << std::endl;
b.join();
std::cout << "main: c.join()" << std::endl;
c.join();
}
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/wait_stuff.cpp | // Copyright Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <algorithm>
#include <cassert>
#include <chrono>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include <boost/fiber/all.hpp>
#include <boost/variant/variant.hpp>
#include <boost/variant/get.hpp>
// These are wait_something() functions rather than when_something()
// functions. A big part of the point of the Fiber library is to model
// sequencing using the processor's instruction pointer rather than chains of
// callbacks. The future-oriented when_all() / when_any() functions are still
// based on chains of callbacks. With Fiber, we can do better.
/*****************************************************************************
* Verbose
*****************************************************************************/
class Verbose {
public:
Verbose( std::string const& d):
desc( d) {
std::cout << desc << " start" << std::endl;
}
~Verbose() {
std::cout << desc << " stop" << std::endl;
}
Verbose( Verbose const&) = delete;
Verbose & operator=( Verbose const&) = delete;
private:
const std::string desc;
};
/*****************************************************************************
* Runner and Example
*****************************************************************************/
// collect and ultimately run every Example
class Runner {
typedef std::vector< std::pair< std::string, std::function< void() > > > function_list;
public:
void add( std::string const& desc, std::function< void() > const& func) {
functions_.push_back( function_list::value_type( desc, func) );
}
void run() {
for ( function_list::value_type const& pair : functions_) {
Verbose v( pair.first);
pair.second();
}
}
private:
function_list functions_;
};
Runner runner;
// Example allows us to embed Runner::add() calls at module scope
struct Example {
Example( Runner & runner, std::string const& desc, std::function< void() > const& func) {
runner.add( desc, func);
}
};
/*****************************************************************************
* example task functions
*****************************************************************************/
//[wait_sleeper
template< typename T >
T sleeper_impl( T item, int ms, bool thrw = false) {
std::ostringstream descb, funcb;
descb << item;
std::string desc( descb.str() );
funcb << " sleeper(" << item << ")";
Verbose v( funcb.str() );
boost::this_fiber::sleep_for( std::chrono::milliseconds( ms) );
if ( thrw) {
throw std::runtime_error( desc);
}
return item;
}
//]
inline
std::string sleeper( std::string const& item, int ms, bool thrw = false) {
return sleeper_impl( item, ms, thrw);
}
inline
double sleeper( double item, int ms, bool thrw = false) {
return sleeper_impl( item, ms, thrw);
}
inline
int sleeper(int item, int ms, bool thrw = false) {
return sleeper_impl( item, ms, thrw);
}
/*****************************************************************************
* Done
*****************************************************************************/
//[wait_done
// Wrap canonical pattern for condition_variable + bool flag
struct Done {
private:
boost::fibers::condition_variable cond;
boost::fibers::mutex mutex;
bool ready = false;
public:
typedef std::shared_ptr< Done > ptr;
void wait() {
std::unique_lock< boost::fibers::mutex > lock( mutex);
cond.wait( lock, [this](){ return ready; });
}
void notify() {
{
std::unique_lock< boost::fibers::mutex > lock( mutex);
ready = true;
} // release mutex
cond.notify_one();
}
};
//]
/*****************************************************************************
* when_any, simple completion
*****************************************************************************/
//[wait_first_simple_impl
// Degenerate case: when there are no functions to wait for, return
// immediately.
void wait_first_simple_impl( Done::ptr) {
}
// When there's at least one function to wait for, launch it and recur to
// process the rest.
template< typename Fn, typename ... Fns >
void wait_first_simple_impl( Done::ptr done, Fn && function, Fns && ... functions) {
boost::fibers::fiber( [done, function](){
function();
done->notify();
}).detach();
wait_first_simple_impl( done, std::forward< Fns >( functions) ... );
}
//]
// interface function: instantiate Done, launch tasks, wait for Done
//[wait_first_simple
template< typename ... Fns >
void wait_first_simple( Fns && ... functions) {
// Use shared_ptr because each function's fiber will bind it separately,
// and we're going to return before the last of them completes.
auto done( std::make_shared< Done >() );
wait_first_simple_impl( done, std::forward< Fns >( functions) ... );
done->wait();
}
//]
// example usage
Example wfs( runner, "wait_first_simple()", [](){
//[wait_first_simple_ex
wait_first_simple(
[](){ sleeper("wfs_long", 150); },
[](){ sleeper("wfs_medium", 100); },
[](){ sleeper("wfs_short", 50); });
//]
});
/*****************************************************************************
* when_any, return value
*****************************************************************************/
// When there's only one function, call this overload
//[wait_first_value_impl
template< typename T, typename Fn >
void wait_first_value_impl( std::shared_ptr< boost::fibers::buffered_channel< T > > chan,
Fn && function) {
boost::fibers::fiber( [chan, function](){
// Ignore channel_op_status returned by push():
// might be closed; we simply don't care.
chan->push( function() );
}).detach();
}
//]
// When there are two or more functions, call this overload
template< typename T, typename Fn0, typename Fn1, typename ... Fns >
void wait_first_value_impl( std::shared_ptr< boost::fibers::buffered_channel< T > > chan,
Fn0 && function0,
Fn1 && function1,
Fns && ... functions) {
// process the first function using the single-function overload
wait_first_value_impl< T >( chan,
std::forward< Fn0 >( function0) );
// then recur to process the rest
wait_first_value_impl< T >( chan,
std::forward< Fn1 >( function1),
std::forward< Fns >( functions) ... );
}
//[wait_first_value
// Assume that all passed functions have the same return type. The return type
// of wait_first_value() is the return type of the first passed function. It is
// simply invalid to pass NO functions.
template< typename Fn, typename ... Fns >
typename std::result_of< Fn() >::type
wait_first_value( Fn && function, Fns && ... functions) {
typedef typename std::result_of< Fn() >::type return_t;
typedef boost::fibers::buffered_channel< return_t > channel_t;
auto chanp( std::make_shared< channel_t >( 64) );
// launch all the relevant fibers
wait_first_value_impl< return_t >( chanp,
std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// retrieve the first value
return_t value( chanp->value_pop() );
// close the channel: no subsequent push() has to succeed
chanp->close();
return value;
}
//]
// example usage
Example wfv( runner, "wait_first_value()", [](){
//[wait_first_value_ex
std::string result = wait_first_value(
[](){ return sleeper("wfv_third", 150); },
[](){ return sleeper("wfv_second", 100); },
[](){ return sleeper("wfv_first", 50); });
std::cout << "wait_first_value() => " << result << std::endl;
assert(result == "wfv_first");
//]
});
/*****************************************************************************
* when_any, produce first outcome, whether result or exception
*****************************************************************************/
// When there's only one function, call this overload.
//[wait_first_outcome_impl
template< typename T, typename CHANP, typename Fn >
void wait_first_outcome_impl( CHANP chan, Fn && function) {
boost::fibers::fiber(
// Use std::bind() here for C++11 compatibility. C++11 lambda capture
// can't move a move-only Fn type, but bind() can. Let bind() move the
// channel pointer and the function into the bound object, passing
// references into the lambda.
std::bind(
[]( CHANP & chan,
typename std::decay< Fn >::type & function) {
// Instantiate a packaged_task to capture any exception thrown by
// function.
boost::fibers::packaged_task< T() > task( function);
// Immediately run this packaged_task on same fiber. We want
// function() to have completed BEFORE we push the future.
task();
// Pass the corresponding future to consumer. Ignore
// channel_op_status returned by push(): might be closed; we
// simply don't care.
chan->push( task.get_future() );
},
chan,
std::forward< Fn >( function)
)).detach();
}
//]
// When there are two or more functions, call this overload
template< typename T, typename CHANP, typename Fn0, typename Fn1, typename ... Fns >
void wait_first_outcome_impl( CHANP chan,
Fn0 && function0,
Fn1 && function1,
Fns && ... functions) {
// process the first function using the single-function overload
wait_first_outcome_impl< T >( chan,
std::forward< Fn0 >( function0) );
// then recur to process the rest
wait_first_outcome_impl< T >( chan,
std::forward< Fn1 >( function1),
std::forward< Fns >( functions) ... );
}
// Assume that all passed functions have the same return type. The return type
// of wait_first_outcome() is the return type of the first passed function. It is
// simply invalid to pass NO functions.
//[wait_first_outcome
template< typename Fn, typename ... Fns >
typename std::result_of< Fn() >::type
wait_first_outcome( Fn && function, Fns && ... functions) {
// In this case, the value we pass through the channel is actually a
// future -- which is already ready. future can carry either a value or an
// exception.
typedef typename std::result_of< Fn() >::type return_t;
typedef boost::fibers::future< return_t > future_t;
typedef boost::fibers::buffered_channel< future_t > channel_t;
auto chanp(std::make_shared< channel_t >( 64) );
// launch all the relevant fibers
wait_first_outcome_impl< return_t >( chanp,
std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// retrieve the first future
future_t future( chanp->value_pop() );
// close the channel: no subsequent push() has to succeed
chanp->close();
// either return value or throw exception
return future.get();
}
//]
// example usage
Example wfo( runner, "wait_first_outcome()", [](){
//[wait_first_outcome_ex
std::string result = wait_first_outcome(
[](){ return sleeper("wfos_first", 50); },
[](){ return sleeper("wfos_second", 100); },
[](){ return sleeper("wfos_third", 150); });
std::cout << "wait_first_outcome(success) => " << result << std::endl;
assert(result == "wfos_first");
std::string thrown;
try {
result = wait_first_outcome(
[](){ return sleeper("wfof_first", 50, true); },
[](){ return sleeper("wfof_second", 100); },
[](){ return sleeper("wfof_third", 150); });
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_first_outcome(fail) threw '" << thrown
<< "'" << std::endl;
assert(thrown == "wfof_first");
//]
});
/*****************************************************************************
* when_any, collect exceptions until success; throw exception_list if no
* success
*****************************************************************************/
// define an exception to aggregate exception_ptrs; prefer
// std::exception_list (N4407 et al.) once that becomes available
//[exception_list
class exception_list : public std::runtime_error {
public:
exception_list( std::string const& what) :
std::runtime_error( what) {
}
typedef std::vector< std::exception_ptr > bundle_t;
// N4407 proposed std::exception_list API
typedef bundle_t::const_iterator iterator;
std::size_t size() const noexcept {
return bundle_.size();
}
iterator begin() const noexcept {
return bundle_.begin();
}
iterator end() const noexcept {
return bundle_.end();
}
// extension to populate
void add( std::exception_ptr ep) {
bundle_.push_back( ep);
}
private:
bundle_t bundle_;
};
//]
// Assume that all passed functions have the same return type. The return type
// of wait_first_success() is the return type of the first passed function. It is
// simply invalid to pass NO functions.
//[wait_first_success
template< typename Fn, typename ... Fns >
typename std::result_of< Fn() >::type
wait_first_success( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
// In this case, the value we pass through the channel is actually a
// future -- which is already ready. future can carry either a value or an
// exception.
typedef typename std::result_of< typename std::decay< Fn >::type() >::type return_t;
typedef boost::fibers::future< return_t > future_t;
typedef boost::fibers::buffered_channel< future_t > channel_t;
auto chanp( std::make_shared< channel_t >( 64) );
// launch all the relevant fibers
wait_first_outcome_impl< return_t >( chanp,
std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// instantiate exception_list, just in case
exception_list exceptions("wait_first_success() produced only errors");
// retrieve up to 'count' results -- but stop there!
for ( std::size_t i = 0; i < count; ++i) {
// retrieve the next future
future_t future( chanp->value_pop() );
// retrieve exception_ptr if any
std::exception_ptr error( future.get_exception_ptr() );
// if no error, then yay, return value
if ( ! error) {
// close the channel: no subsequent push() has to succeed
chanp->close();
// show caller the value we got
return future.get();
}
// error is non-null: collect
exceptions.add( error);
}
// We only arrive here when every passed function threw an exception.
// Throw our collection to inform caller.
throw exceptions;
}
//]
// example usage
Example wfss( runner, "wait_first_success()", [](){
//[wait_first_success_ex
std::string result = wait_first_success(
[](){ return sleeper("wfss_first", 50, true); },
[](){ return sleeper("wfss_second", 100); },
[](){ return sleeper("wfss_third", 150); });
std::cout << "wait_first_success(success) => " << result << std::endl;
assert(result == "wfss_second");
//]
std::string thrown;
std::size_t count = 0;
try {
result = wait_first_success(
[](){ return sleeper("wfsf_first", 50, true); },
[](){ return sleeper("wfsf_second", 100, true); },
[](){ return sleeper("wfsf_third", 150, true); });
} catch ( exception_list const& e) {
thrown = e.what();
count = e.size();
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_first_success(fail) threw '" << thrown << "': "
<< count << " errors" << std::endl;
assert(thrown == "wait_first_success() produced only errors");
assert(count == 3);
});
/*****************************************************************************
* when_any, heterogeneous
*****************************************************************************/
//[wait_first_value_het
// No need to break out the first Fn for interface function: let the compiler
// complain if empty.
// Our functions have different return types, and we might have to return any
// of them. Use a variant, expanding std::result_of<Fn()>::type for each Fn in
// parameter pack.
template< typename ... Fns >
boost::variant< typename std::result_of< Fns() >::type ... >
wait_first_value_het( Fns && ... functions) {
// Use buffered_channel<boost::variant<T1, T2, ...>>; see remarks above.
typedef boost::variant< typename std::result_of< Fns() >::type ... > return_t;
typedef boost::fibers::buffered_channel< return_t > channel_t;
auto chanp( std::make_shared< channel_t >( 64) );
// launch all the relevant fibers
wait_first_value_impl< return_t >( chanp,
std::forward< Fns >( functions) ... );
// retrieve the first value
return_t value( chanp->value_pop() );
// close the channel: no subsequent push() has to succeed
chanp->close();
return value;
}
//]
// example usage
Example wfvh( runner, "wait_first_value_het()", [](){
//[wait_first_value_het_ex
boost::variant< std::string, double, int > result =
wait_first_value_het(
[](){ return sleeper("wfvh_third", 150); },
[](){ return sleeper(3.14, 100); },
[](){ return sleeper(17, 50); });
std::cout << "wait_first_value_het() => " << result << std::endl;
assert(boost::get< int >( result) == 17);
//]
});
/*****************************************************************************
* when_all, simple completion
*****************************************************************************/
// Degenerate case: when there are no functions to wait for, return
// immediately.
void wait_all_simple_impl( std::shared_ptr< boost::fibers::barrier >) {
}
// When there's at least one function to wait for, launch it and recur to
// process the rest.
//[wait_all_simple_impl
template< typename Fn, typename ... Fns >
void wait_all_simple_impl( std::shared_ptr< boost::fibers::barrier > barrier,
Fn && function, Fns && ... functions) {
boost::fibers::fiber(
std::bind(
[]( std::shared_ptr< boost::fibers::barrier > & barrier,
typename std::decay< Fn >::type & function) mutable {
function();
barrier->wait();
},
barrier,
std::forward< Fn >( function)
)).detach();
wait_all_simple_impl( barrier, std::forward< Fns >( functions) ... );
}
//]
// interface function: instantiate barrier, launch tasks, wait for barrier
//[wait_all_simple
template< typename ... Fns >
void wait_all_simple( Fns && ... functions) {
std::size_t count( sizeof ... ( functions) );
// Initialize a barrier(count+1) because we'll immediately wait on it. We
// don't want to wake up until 'count' more fibers wait on it. Even though
// we'll stick around until the last of them completes, use shared_ptr
// anyway because it's easier to be confident about lifespan issues.
auto barrier( std::make_shared< boost::fibers::barrier >( count + 1) );
wait_all_simple_impl( barrier, std::forward< Fns >( functions) ... );
barrier->wait();
}
//]
// example usage
Example was( runner, "wait_all_simple()", [](){
//[wait_all_simple_ex
wait_all_simple(
[](){ sleeper("was_long", 150); },
[](){ sleeper("was_medium", 100); },
[](){ sleeper("was_short", 50); });
//]
});
/*****************************************************************************
* when_all, return values
*****************************************************************************/
//[wait_nchannel
// Introduce a channel facade that closes the channel once a specific number
// of items has been pushed. This allows an arbitrary consumer to read until
// 'closed' without itself having to count items.
template< typename T >
class nchannel {
public:
nchannel( std::shared_ptr< boost::fibers::buffered_channel< T > > chan,
std::size_t lm):
chan_( chan),
limit_( lm) {
assert(chan_);
if ( 0 == limit_) {
chan_->close();
}
}
boost::fibers::channel_op_status push( T && va) {
boost::fibers::channel_op_status ok =
chan_->push( std::forward< T >( va) );
if ( ok == boost::fibers::channel_op_status::success &&
--limit_ == 0) {
// after the 'limit_'th successful push, close the channel
chan_->close();
}
return ok;
}
private:
std::shared_ptr< boost::fibers::buffered_channel< T > > chan_;
std::size_t limit_;
};
//]
// When there's only one function, call this overload
//[wait_all_values_impl
template< typename T, typename Fn >
void wait_all_values_impl( std::shared_ptr< nchannel< T > > chan,
Fn && function) {
boost::fibers::fiber( [chan, function](){
chan->push(function());
}).detach();
}
//]
// When there are two or more functions, call this overload
template< typename T, typename Fn0, typename Fn1, typename ... Fns >
void wait_all_values_impl( std::shared_ptr< nchannel< T > > chan,
Fn0 && function0,
Fn1 && function1,
Fns && ... functions) {
// process the first function using the single-function overload
wait_all_values_impl< T >( chan, std::forward< Fn0 >( function0) );
// then recur to process the rest
wait_all_values_impl< T >( chan,
std::forward< Fn1 >( function1),
std::forward< Fns >( functions) ... );
}
//[wait_all_values_source
// Return a shared_ptr<buffered_channel<T>> from which the caller can
// retrieve each new result as it arrives, until 'closed'.
template< typename Fn, typename ... Fns >
std::shared_ptr< boost::fibers::buffered_channel< typename std::result_of< Fn() >::type > >
wait_all_values_source( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
typedef typename std::result_of< Fn() >::type return_t;
typedef boost::fibers::buffered_channel< return_t > channel_t;
// make the channel
auto chanp( std::make_shared< channel_t >( 64) );
// and make an nchannel facade to close it after 'count' items
auto ncp( std::make_shared< nchannel< return_t > >( chanp, count) );
// pass that nchannel facade to all the relevant fibers
wait_all_values_impl< return_t >( ncp,
std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// then return the channel for consumer
return chanp;
}
//]
// When all passed functions have completed, return vector<T> containing
// collected results. Assume that all passed functions have the same return
// type. It is simply invalid to pass NO functions.
//[wait_all_values
template< typename Fn, typename ... Fns >
std::vector< typename std::result_of< Fn() >::type >
wait_all_values( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
typedef typename std::result_of< Fn() >::type return_t;
typedef std::vector< return_t > vector_t;
vector_t results;
results.reserve( count);
// get channel
std::shared_ptr< boost::fibers::buffered_channel< return_t > > chan =
wait_all_values_source( std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// fill results vector
return_t value;
while ( boost::fibers::channel_op_status::success == chan->pop(value) ) {
results.push_back( value);
}
// return vector to caller
return results;
}
//]
Example wav( runner, "wait_all_values()", [](){
//[wait_all_values_source_ex
std::shared_ptr< boost::fibers::buffered_channel< std::string > > chan =
wait_all_values_source(
[](){ return sleeper("wavs_third", 150); },
[](){ return sleeper("wavs_second", 100); },
[](){ return sleeper("wavs_first", 50); });
std::string value;
while ( boost::fibers::channel_op_status::success == chan->pop(value) ) {
std::cout << "wait_all_values_source() => '" << value
<< "'" << std::endl;
}
//]
//[wait_all_values_ex
std::vector< std::string > values =
wait_all_values(
[](){ return sleeper("wav_late", 150); },
[](){ return sleeper("wav_middle", 100); },
[](){ return sleeper("wav_early", 50); });
//]
std::cout << "wait_all_values() =>";
for ( std::string const& v : values) {
std::cout << " '" << v << "'";
}
std::cout << std::endl;
});
/*****************************************************************************
* when_all, throw first exception
*****************************************************************************/
//[wait_all_until_error_source
// Return a shared_ptr<buffered_channel<future<T>>> from which the caller can
// get() each new result as it arrives, until 'closed'.
template< typename Fn, typename ... Fns >
std::shared_ptr<
boost::fibers::buffered_channel<
boost::fibers::future<
typename std::result_of< Fn() >::type > > >
wait_all_until_error_source( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
typedef typename std::result_of< Fn() >::type return_t;
typedef boost::fibers::future< return_t > future_t;
typedef boost::fibers::buffered_channel< future_t > channel_t;
// make the channel
auto chanp( std::make_shared< channel_t >( 64) );
// and make an nchannel facade to close it after 'count' items
auto ncp( std::make_shared< nchannel< future_t > >( chanp, count) );
// pass that nchannel facade to all the relevant fibers
wait_first_outcome_impl< return_t >( ncp,
std::forward< Fn >( function),
std::forward< Fns >( functions) ... );
// then return the channel for consumer
return chanp;
}
//]
// When all passed functions have completed, return vector<T> containing
// collected results, or throw the first exception thrown by any of the passed
// functions. Assume that all passed functions have the same return type. It
// is simply invalid to pass NO functions.
//[wait_all_until_error
template< typename Fn, typename ... Fns >
std::vector< typename std::result_of< Fn() >::type >
wait_all_until_error( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
typedef typename std::result_of< Fn() >::type return_t;
typedef typename boost::fibers::future< return_t > future_t;
typedef std::vector< return_t > vector_t;
vector_t results;
results.reserve( count);
// get channel
std::shared_ptr<
boost::fibers::buffered_channel< future_t > > chan(
wait_all_until_error_source( std::forward< Fn >( function),
std::forward< Fns >( functions) ... ) );
// fill results vector
future_t future;
while ( boost::fibers::channel_op_status::success == chan->pop( future) ) {
results.push_back( future.get() );
}
// return vector to caller
return results;
}
//]
Example waue( runner, "wait_all_until_error()", [](){
//[wait_all_until_error_source_ex
typedef boost::fibers::future< std::string > future_t;
std::shared_ptr< boost::fibers::buffered_channel< future_t > > chan =
wait_all_until_error_source(
[](){ return sleeper("wauess_third", 150); },
[](){ return sleeper("wauess_second", 100); },
[](){ return sleeper("wauess_first", 50); });
future_t future;
while ( boost::fibers::channel_op_status::success == chan->pop( future) ) {
std::string value( future.get() );
std::cout << "wait_all_until_error_source(success) => '" << value
<< "'" << std::endl;
}
//]
chan = wait_all_until_error_source(
[](){ return sleeper("wauesf_third", 150); },
[](){ return sleeper("wauesf_second", 100, true); },
[](){ return sleeper("wauesf_first", 50); });
//[wait_all_until_error_ex
std::string thrown;
//<-
try {
while ( boost::fibers::channel_op_status::success == chan->pop( future) ) {
std::string value( future.get() );
std::cout << "wait_all_until_error_source(fail) => '" << value
<< "'" << std::endl;
}
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_all_until_error_source(fail) threw '" << thrown
<< "'" << std::endl;
thrown.clear();
//->
try {
std::vector< std::string > values = wait_all_until_error(
[](){ return sleeper("waue_late", 150); },
[](){ return sleeper("waue_middle", 100, true); },
[](){ return sleeper("waue_early", 50); });
//<-
std::cout << "wait_all_until_error(fail) =>";
for ( std::string const& v : values) {
std::cout << " '" << v << "'";
}
std::cout << std::endl;
//->
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_all_until_error(fail) threw '" << thrown
<< "'" << std::endl;
//]
});
/*****************************************************************************
* when_all, collect exceptions
*****************************************************************************/
// When all passed functions have succeeded, return vector<T> containing
// collected results, or throw exception_list containing all exceptions thrown
// by any of the passed functions. Assume that all passed functions have the
// same return type. It is simply invalid to pass NO functions.
//[wait_all_collect_errors
template< typename Fn, typename ... Fns >
std::vector< typename std::result_of< Fn() >::type >
wait_all_collect_errors( Fn && function, Fns && ... functions) {
std::size_t count( 1 + sizeof ... ( functions) );
typedef typename std::result_of< Fn() >::type return_t;
typedef typename boost::fibers::future< return_t > future_t;
typedef std::vector< return_t > vector_t;
vector_t results;
results.reserve( count);
exception_list exceptions("wait_all_collect_errors() exceptions");
// get channel
std::shared_ptr<
boost::fibers::buffered_channel< future_t > > chan(
wait_all_until_error_source( std::forward< Fn >( function),
std::forward< Fns >( functions) ... ) );
// fill results and/or exceptions vectors
future_t future;
while ( boost::fibers::channel_op_status::success == chan->pop( future) ) {
std::exception_ptr exp = future.get_exception_ptr();
if ( ! exp) {
results.push_back( future.get() );
} else {
exceptions.add( exp);
}
}
// if there were any exceptions, throw
if ( exceptions.size() ) {
throw exceptions;
}
// no exceptions: return vector to caller
return results;
}
//]
Example wace( runner, "wait_all_collect_errors()", [](){
std::vector< std::string > values = wait_all_collect_errors(
[](){ return sleeper("waces_late", 150); },
[](){ return sleeper("waces_middle", 100); },
[](){ return sleeper("waces_early", 50); });
std::cout << "wait_all_collect_errors(success) =>";
for ( std::string const& v : values) {
std::cout << " '" << v << "'";
}
std::cout << std::endl;
std::string thrown;
std::size_t errors = 0;
try {
values = wait_all_collect_errors(
[](){ return sleeper("wacef_late", 150, true); },
[](){ return sleeper("wacef_middle", 100, true); },
[](){ return sleeper("wacef_early", 50); });
std::cout << "wait_all_collect_errors(fail) =>";
for ( std::string const& v : values) {
std::cout << " '" << v << "'";
}
std::cout << std::endl;
} catch ( exception_list const& e) {
thrown = e.what();
errors = e.size();
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_all_collect_errors(fail) threw '" << thrown
<< "': " << errors << " errors" << std::endl;
});
/*****************************************************************************
* when_all, heterogeneous
*****************************************************************************/
//[wait_all_members_get
template< typename Result, typename ... Futures >
Result wait_all_members_get( Futures && ... futures) {
// Fetch the results from the passed futures into Result's initializer
// list. It's true that the get() calls here will block the implicit
// iteration over futures -- but that doesn't matter because we won't be
// done until the slowest of them finishes anyway. As results are
// processed in argument-list order rather than order of completion, the
// leftmost get() to throw an exception will cause that exception to
// propagate to the caller.
return Result{ futures.get() ... };
}
//]
//[wait_all_members
// Explicitly pass Result. This can be any type capable of being initialized
// from the results of the passed functions, such as a struct.
template< typename Result, typename ... Fns >
Result wait_all_members( Fns && ... functions) {
// Run each of the passed functions on a separate fiber, passing all their
// futures to helper function for processing.
return wait_all_members_get< Result >(
boost::fibers::async( std::forward< Fns >( functions) ) ... );
}
//]
// used by following example
//[wait_Data
struct Data {
std::string str;
double inexact;
int exact;
friend std::ostream& operator<<( std::ostream& out, Data const& data)/*=;
...*/
//<-
{
return out << "Data{str='" << data.str << "', inexact=" << data.inexact
<< ", exact=" << data.exact << "}";
}
//->
};
//]
// example usage
Example wam( runner, "wait_all_members()", [](){
//[wait_all_members_data_ex
Data data = wait_all_members< Data >(
[](){ return sleeper("wams_left", 100); },
[](){ return sleeper(3.14, 150); },
[](){ return sleeper(17, 50); });
std::cout << "wait_all_members<Data>(success) => " << data << std::endl;
//]
std::string thrown;
try {
data = wait_all_members< Data >(
[](){ return sleeper("wamf_left", 100, true); },
[](){ return sleeper(3.14, 150); },
[](){ return sleeper(17, 50, true); });
std::cout << "wait_all_members<Data>(fail) => " << data << std::endl;
} catch ( std::exception const& e) {
thrown = e.what();
}
std::cout << "wait_all_members<Data>(fail) threw '" << thrown
<< '"' << std::endl;
//[wait_all_members_vector_ex
// If we don't care about obtaining results as soon as they arrive, and we
// prefer a result vector in passed argument order rather than completion
// order, wait_all_members() is another possible implementation of
// wait_all_until_error().
auto strings = wait_all_members< std::vector< std::string > >(
[](){ return sleeper("wamv_left", 150); },
[](){ return sleeper("wamv_middle", 100); },
[](){ return sleeper("wamv_right", 50); });
std::cout << "wait_all_members<vector>() =>";
for ( std::string const& str : strings) {
std::cout << " '" << str << "'";
}
std::cout << std::endl;
//]
});
/*****************************************************************************
* main()
*****************************************************************************/
int main( int argc, char *argv[]) {
runner.run();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/range_for.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
#include <boost/fiber/all.hpp>
typedef boost::fibers::unbuffered_channel< unsigned int > channel_t;
void foo( channel_t & chan) {
chan.push( 1);
chan.push( 1);
chan.push( 2);
chan.push( 3);
chan.push( 5);
chan.push( 8);
chan.push( 12);
chan.close();
}
void bar( channel_t & chan) {
for ( unsigned int value : chan) {
std::cout << value << " ";
}
std::cout << std::endl;
}
int main() {
try {
channel_t chan;
boost::fibers::fiber f1( & foo, std::ref( chan) );
boost::fibers::fiber f2( & bar, std::ref( chan) );
f1.join();
f2.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/examples/future.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <exception>
#include <functional>
#include <iostream>
#include <string>
#include <boost/fiber/all.hpp>
inline
int fn( std::string const& str, int n)
{
for ( int i = 0; i < n; ++i)
{
std::cout << i << ": " << str << std::endl;
boost::this_fiber::yield();
}
return n;
}
void start()
{
boost::fibers::future< int > fi(
boost::fibers::async(
std::bind( fn, "abc", 5) ) );
fi.wait();
std::cout << "fn() returned " << fi.get() << std::endl;
}
int main()
{
try
{
boost::fibers::fiber( start).join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
catch ( std::exception const& e)
{ std::cerr << "exception: " << e.what() << std::endl; }
catch (...)
{ std::cerr << "unhandled exception" << std::endl; }
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/examples/simple.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <boost/intrusive_ptr.hpp>
#include <boost/fiber/all.hpp>
inline
void fn( std::string const& str, int n) {
for ( int i = 0; i < n; ++i) {
std::cout << i << ": " << str << std::endl;
boost::this_fiber::yield();
}
}
int main() {
try {
boost::fibers::fiber f1( fn, "abc", 5);
std::cerr << "f1 : " << f1.get_id() << std::endl;
f1.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/examples/adapt_callbacks.cpp | // Copyright Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cassert>
#include <chrono>
#include <exception>
#include <iostream>
#include <sstream>
#include <thread>
#include <tuple> // std::tie()
#include <boost/context/detail/apply.hpp>
#include <boost/fiber/all.hpp>
#if defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
/*****************************************************************************
* helper code to help callback
*****************************************************************************/
template< typename Fn, typename ... Args >
class helper {
private:
typename std::decay< Fn >::type fn_;
std::tuple< typename std::decay< Args >::type ... > args_;
public:
helper( Fn && fn, Args && ... args) :
fn_( std::forward< Fn >( fn) ),
args_( std::make_tuple( std::forward< Args >( args) ... ) ) {
}
helper( helper && other) = default;
helper & operator=( helper && other) = default;
helper( helper const&) = default;
helper & operator=( helper const&) = default;
void operator()() {
boost::context::detail::apply( fn_, args_);
}
};
template< typename Fn, typename ... Args >
helper< Fn, Args ... > help( Fn && fn, Args && ... args) {
return helper< Fn, Args ... >( std::forward< Fn >( fn), std::forward< Args >( args) ... );
}
#endif
/*****************************************************************************
* example async API
*****************************************************************************/
//[AsyncAPI
class AsyncAPI {
public:
// constructor acquires some resource that can be read and written
AsyncAPI();
// callbacks accept an int error code; 0 == success
typedef int errorcode;
// write callback only needs to indicate success or failure
template< typename Fn >
void init_write( std::string const& data, Fn && callback);
// read callback needs to accept both errorcode and data
template< typename Fn >
void init_read( Fn && callback);
// ... other operations ...
//<-
void inject_error( errorcode ec);
private:
std::string data_;
errorcode injected_;
//->
};
//]
/*****************************************************************************
* fake AsyncAPI implementation... pay no attention to the little man behind
* the curtain...
*****************************************************************************/
AsyncAPI::AsyncAPI() :
injected_( 0) {
}
void AsyncAPI::inject_error( errorcode ec) {
injected_ = ec;
}
template< typename Fn >
void AsyncAPI::init_write( std::string const& data, Fn && callback) {
// make a local copy of injected_
errorcode injected( injected_);
// reset it synchronously with caller
injected_ = 0;
// update data_ (this might be an echo service)
if ( ! injected) {
data_ = data;
}
// Simulate an asynchronous I/O operation by launching a detached thread
// that sleeps a bit before calling completion callback. Echo back to
// caller any previously-injected errorcode.
#if ! defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
std::thread( [injected,callback=std::forward< Fn >( callback)]() mutable {
std::this_thread::sleep_for( std::chrono::milliseconds(100) );
callback( injected);
}).detach();
#else
std::thread(
std::move(
help( std::forward< Fn >( callback), injected) ) ).detach();
#endif
}
template< typename Fn >
void AsyncAPI::init_read( Fn && callback) {
// make a local copy of injected_
errorcode injected( injected_);
// reset it synchronously with caller
injected_ = 0;
// local copy of data_ so we can capture in lambda
std::string data( data_);
// Simulate an asynchronous I/O operation by launching a detached thread
// that sleeps a bit before calling completion callback. Echo back to
// caller any previously-injected errorcode.
#if ! defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
std::thread( [injected,callback=std::forward< Fn >( callback),data]() mutable {
std::this_thread::sleep_for( std::chrono::milliseconds(100) );
callback( injected, data);
}).detach();
#else
std::thread(
std::move(
help( std::forward< Fn >( callback), injected, data) ) ).detach();
#endif
}
/*****************************************************************************
* adapters
*****************************************************************************/
// helper function used in a couple of the adapters
std::runtime_error make_exception( std::string const& desc, AsyncAPI::errorcode);
//[callbacks_write_ec
AsyncAPI::errorcode write_ec( AsyncAPI & api, std::string const& data) {
boost::fibers::promise< AsyncAPI::errorcode > promise;
boost::fibers::future< AsyncAPI::errorcode > future( promise.get_future() );
// In general, even though we block waiting for future::get() and therefore
// won't destroy 'promise' until promise::set_value() has been called, we
// are advised that with threads it's possible for ~promise() to be
// entered before promise::set_value() has returned. While that shouldn't
// happen with fibers::promise, a robust way to deal with the lifespan
// issue is to bind 'promise' into our lambda. Since promise is move-only,
// use initialization capture.
#if ! defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_write(
data,
[promise=std::move( promise)]( AsyncAPI::errorcode ec) mutable {
promise.set_value( ec);
});
#else // defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_write(
data,
std::bind([](boost::fibers::promise< AsyncAPI::errorcode > & promise,
AsyncAPI::errorcode ec) {
promise.set_value( ec);
},
std::move( promise),
std::placeholders::_1) );
#endif // BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
return future.get();
}
//]
//[callbacks_write
void write( AsyncAPI & api, std::string const& data) {
AsyncAPI::errorcode ec = write_ec( api, data);
if ( ec) {
throw make_exception("write", ec);
}
}
//]
//[callbacks_read_ec
std::pair< AsyncAPI::errorcode, std::string > read_ec( AsyncAPI & api) {
typedef std::pair< AsyncAPI::errorcode, std::string > result_pair;
boost::fibers::promise< result_pair > promise;
boost::fibers::future< result_pair > future( promise.get_future() );
// We promise that both 'promise' and 'future' will survive until our
// lambda has been called.
#if ! defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_read([promise=std::move( promise)]( AsyncAPI::errorcode ec, std::string const& data) mutable {
promise.set_value( result_pair( ec, data) );
});
#else // defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_read(
std::bind([]( boost::fibers::promise< result_pair > & promise,
AsyncAPI::errorcode ec, std::string const& data) mutable {
promise.set_value( result_pair( ec, data) );
},
std::move( promise),
std::placeholders::_1,
std::placeholders::_2) );
#endif // BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
return future.get();
}
//]
//[callbacks_read
std::string read( AsyncAPI & api) {
boost::fibers::promise< std::string > promise;
boost::fibers::future< std::string > future( promise.get_future() );
// Both 'promise' and 'future' will survive until our lambda has been
// called.
#if ! defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_read([&promise]( AsyncAPI::errorcode ec, std::string const& data) mutable {
if ( ! ec) {
promise.set_value( data);
} else {
promise.set_exception(
std::make_exception_ptr(
make_exception("read", ec) ) );
}
});
#else // defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)
api.init_read(
std::bind([]( boost::fibers::promise< std::string > & promise,
AsyncAPI::errorcode ec, std::string const& data) mutable {
if ( ! ec) {
promise.set_value( data);
} else {
promise.set_exception(
std::make_exception_ptr(
make_exception("read", ec) ) );
}
},
std::move( promise),
std::placeholders::_1,
std::placeholders::_2) );
#endif // BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
return future.get();
}
//]
/*****************************************************************************
* helpers
*****************************************************************************/
std::runtime_error make_exception( std::string const& desc, AsyncAPI::errorcode ec) {
std::ostringstream buffer;
buffer << "Error in AsyncAPI::" << desc << "(): " << ec;
return std::runtime_error( buffer.str() );
}
/*****************************************************************************
* driving logic
*****************************************************************************/
int main( int argc, char *argv[]) {
AsyncAPI api;
// successful write(): prime AsyncAPI with some data
write( api, "abcd");
// successful read(): retrieve it
std::string data( read( api) );
assert( data == "abcd");
// successful write_ec()
AsyncAPI::errorcode ec( write_ec( api, "efgh") );
assert( ec == 0);
// write_ec() with error
api.inject_error(1);
ec = write_ec( api, "ijkl");
assert( ec == 1);
// write() with error
std::string thrown;
api.inject_error(2);
try {
write(api, "mnop");
} catch ( std::exception const& e) {
thrown = e.what();
}
assert( thrown == make_exception("write", 2).what() );
// successful read_ec()
//[callbacks_read_ec_call
std::tie( ec, data) = read_ec( api);
//]
assert( ! ec);
assert( data == "efgh"); // last successful write_ec()
// read_ec() with error
api.inject_error(3);
std::tie( ec, data) = read_ec( api);
assert( ec == 3);
// 'data' in unspecified state, don't test
// read() with error
thrown.clear();
api.inject_error(4);
try {
data = read(api);
} catch ( std::exception const& e) {
thrown = e.what();
}
assert( thrown == make_exception("read", 4).what() );
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/barrier.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <boost/assert.hpp>
#include <boost/fiber/all.hpp>
int value1 = 0;
int value2 = 0;
inline
void fn1( boost::fibers::barrier & b)
{
boost::fibers::fiber::id id = boost::this_fiber::get_id();
std::cout << "fiber " << id << ": fn1 entered" << std::endl;
++value1;
std::cout << "fiber " << id << ": incremented value1: " << value1 << std::endl;
boost::this_fiber::yield();
std::cout << "fiber " << id << ": waits for barrier" << std::endl;
b.wait();
std::cout << "fiber " << id << ": passed barrier" << std::endl;
++value1;
std::cout << "fiber " << id << ": incremented value1: " << value1 << std::endl;
boost::this_fiber::yield();
++value1;
std::cout << "fiber " << id << ": incremented value1: " << value1 << std::endl;
boost::this_fiber::yield();
++value1;
std::cout << "fiber " << id << ": incremented value1: " << value1 << std::endl;
boost::this_fiber::yield();
std::cout << "fiber " << id << ": fn1 returns" << std::endl;
}
inline
void fn2( boost::fibers::barrier & b)
{
boost::fibers::fiber::id id = boost::this_fiber::get_id();
std::cout << "fiber " << id << ": fn2 entered" << std::endl;
++value2;
std::cout << "fiber " << id << ": incremented value2: " << value2 << std::endl;
boost::this_fiber::yield();
++value2;
std::cout << "fiber " << id << ": incremented value2: " << value2 << std::endl;
boost::this_fiber::yield();
++value2;
std::cout << "fiber " << id << ": incremented value2: " << value2 << std::endl;
boost::this_fiber::yield();
std::cout << "fiber " << id << ": waits for barrier" << std::endl;
b.wait();
std::cout << "fiber " << id << ": passed barrier" << std::endl;
++value2;
std::cout << "fiber " << id << ": incremented value2: " << value2 << std::endl;
boost::this_fiber::yield();
std::cout << "fiber " << id << ": fn2 returns" << std::endl;
}
int main()
{
try
{
boost::fibers::barrier fb( 2);
boost::fibers::fiber f1( & fn1, std::ref( fb) );
boost::fibers::fiber f2( & fn2, std::ref( fb) );
f1.join();
f2.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
catch ( std::exception const& e)
{ std::cerr << "exception: " << e.what() << std::endl; }
catch (...)
{ std::cerr << "unhandled exception" << std::endl; }
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/examples/work_stealing.cpp | // Copyright Nat Goodspeed + Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <sstream>
#include <string>
#include <thread>
#include <boost/assert.hpp>
#include <boost/fiber/all.hpp>
#include <boost/fiber/detail/thread_barrier.hpp>
static std::size_t fiber_count{ 0 };
static std::mutex mtx_count{};
static boost::fibers::condition_variable_any cnd_count{};
typedef std::unique_lock< std::mutex > lock_type;
/*****************************************************************************
* example fiber function
*****************************************************************************/
//[fiber_fn_ws
void whatevah( char me) {
try {
std::thread::id my_thread = std::this_thread::get_id(); /*< get ID of initial thread >*/
{
std::ostringstream buffer;
buffer << "fiber " << me << " started on thread " << my_thread << '\n';
std::cout << buffer.str() << std::flush;
}
for ( unsigned i = 0; i < 10; ++i) { /*< loop ten times >*/
boost::this_fiber::yield(); /*< yield to other fibers >*/
std::thread::id new_thread = std::this_thread::get_id(); /*< get ID of current thread >*/
if ( new_thread != my_thread) { /*< test if fiber was migrated to another thread >*/
my_thread = new_thread;
std::ostringstream buffer;
buffer << "fiber " << me << " switched to thread " << my_thread << '\n';
std::cout << buffer.str() << std::flush;
}
}
} catch ( ... ) {
}
lock_type lk( mtx_count);
if ( 0 == --fiber_count) { /*< Decrement fiber counter for each completed fiber. >*/
lk.unlock();
cnd_count.notify_all(); /*< Notify all fibers waiting on `cnd_count`. >*/
}
}
//]
/*****************************************************************************
* example thread function
*****************************************************************************/
//[thread_fn_ws
void thread() {
std::ostringstream buffer;
buffer << "thread started " << std::this_thread::get_id() << std::endl;
std::cout << buffer.str() << std::flush;
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( 4); /*<
Install the scheduling algorithm `boost::fibers::algo::work_stealing` in order to
join the work sharing.
>*/
lock_type lk( mtx_count);
cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /*<
Suspend main fiber and resume worker fibers in the meanwhile.
Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
if all worker fibers are complete.
>*/
BOOST_ASSERT( 0 == fiber_count);
}
//]
/*****************************************************************************
* main()
*****************************************************************************/
int main( int argc, char *argv[]) {
std::cout << "main thread started " << std::this_thread::get_id() << std::endl;
//[main_ws
for ( char c : std::string("abcdefghijklmnopqrstuvwxyz")) { /*<
Launch a number of worker fibers; each worker fiber picks up a character
that is passed as parameter to fiber-function `whatevah`.
Each worker fiber gets detached.
>*/
boost::fibers::fiber([c](){ whatevah( c); }).detach();
++fiber_count; /*< Increment fiber counter for each new fiber. >*/
}
std::thread threads[] = { /*<
Launch a couple of threads that join the work sharing.
>*/
std::thread( thread),
std::thread( thread),
std::thread( thread)
};
boost::fibers::use_scheduling_algorithm< boost::fibers::algo::work_stealing >( 4); /*<
Install the scheduling algorithm `boost::fibers::algo::work_stealing` in the main thread
too, so each new fiber gets launched into the shared pool.
>*/
{
lock_type/*< `lock_type` is typedef'ed as __unique_lock__< [@http://en.cppreference.com/w/cpp/thread/mutex `std::mutex`] > >*/ lk( mtx_count);
cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /*<
Suspend main fiber and resume worker fibers in the meanwhile.
Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
if all worker fibers are complete.
>*/
} /*<
Releasing lock of mtx_count is required before joining the threads, otherwise
the other threads would be blocked inside condition_variable::wait() and
would never return (deadlock).
>*/
BOOST_ASSERT( 0 == fiber_count);
for ( std::thread & t : threads) { /*< wait for threads to terminate >*/
t.join();
}
//]
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
|
0 | repos/fiber | repos/fiber/examples/join.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <functional>
#include <stdexcept>
#include <iostream>
#include <string>
#include <boost/fiber/all.hpp>
int value1 = 0;
int value2 = 0;
void fn1()
{
boost::fibers::fiber::id this_id = boost::this_fiber::get_id();
for ( int i = 0; i < 5; ++i)
{
++value1;
std::cout << "fiber " << this_id << " fn1: increment value1: " << value1 << std::endl;
boost::this_fiber::yield();
}
std::cout << "fiber " << this_id << " fn1: returns" << std::endl;
}
void fn2( boost::fibers::fiber & f)
{
boost::fibers::fiber::id this_id = boost::this_fiber::get_id();
for ( int i = 0; i < 5; ++i)
{
++value2;
std::cout << "fiber " << this_id << " fn2: increment value2: " << value2 << std::endl;
if ( i == 1)
{
boost::fibers::fiber::id id = f.get_id();
std::cout << "fiber " << this_id << " fn2: joins fiber " << id << std::endl;
f.join();
std::cout << "fiber " << this_id << " fn2: joined fiber " << id << std::endl;
}
boost::this_fiber::yield();
}
std::cout << "fiber " << this_id << " fn2: returns" << std::endl;
}
int main()
{
try
{
boost::fibers::fiber f1( fn1);
boost::fibers::fiber f2( fn2, std::ref( f1) );
f2.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
catch ( std::exception const& e)
{ std::cerr << "exception: " << e.what() << std::endl; }
catch (...)
{ std::cerr << "unhandled exception" << std::endl; }
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/examples/ping_pong.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
#include <boost/fiber/all.hpp>
int main() {
using channel_t = boost::fibers::buffered_channel< std::string >;
try {
channel_t chan1{ 2 }, chan2{ 2 };
boost::fibers::fiber fping([&chan1,&chan2]{
chan1.push( "ping");
std::cout << chan2.value_pop() << "\n";
chan1.push( "ping");
std::cout << chan2.value_pop() << "\n";
chan1.push( "ping");
std::cout << chan2.value_pop() << "\n";
});
boost::fibers::fiber fpong([&chan1,&chan2]{
std::cout << chan1.value_pop() << "\n";
chan2.push( "pong");
std::cout << chan1.value_pop() << "\n";
chan2.push( "pong");
std::cout << chan1.value_pop() << "\n";
chan2.push( "pong");
});
fping.join();
fpong.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
}
catch ( std::exception const& e)
{ std::cerr << "exception: " << e.what() << std::endl; }
catch (...)
{ std::cerr << "unhandled exception" << std::endl; }
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples | repos/fiber/examples/numa/topology.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstdlib>
#include <cstring>
#include <exception>
#include <iostream>
#include <vector>
#include <boost/assert.hpp>
#include <boost/fiber/numa/topology.hpp>
int main( int argc, char * argv[]) {
try {
std::vector< boost::fibers::numa::node > topo = boost::fibers::numa::topology();
for ( auto n : topo) {
std::cout << "node: " << n.id << " | ";
std::cout << "cpus: ";
for ( auto cpu_id : n.logical_cpus) {
std::cout << cpu_id << " ";
}
std::cout << "| distance: ";
for ( auto d : n.distance) {
std::cout << d << " ";
}
std::cout << std::endl;
}
std::cout << "done" << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& ex) {
std::cerr << "exception: " << ex.what() << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples | repos/fiber/examples/hip/single_stream.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <random>
#include <tuple>
#include <hip/hip_runtime.h>
#include <boost/assert.hpp>
#include <boost/bind.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/fiber/all.hpp>
#include <boost/fiber/hip/waitfor.hpp>
__global__
void vector_add(hipLaunchParm lp, int * a, int * b, int * c, int size) {
int idx = threadIdx.x + blockIdx.x * blockDim.x;
if ( idx < size) {
c[idx] = a[idx] + b[idx];
}
}
int main() {
try {
bool done = false;
boost::fibers::fiber f1([&done]{
std::cout << "f1: entered" << std::endl;
try {
hipStream_t stream;
hipStreamCreate( & stream);
int size = 1024 * 1024;
int full_size = 20 * size;
int * host_a, * host_b, * host_c;
hipHostMalloc( & host_a, full_size * sizeof( int), hipHostMallocDefault);
hipHostMalloc( & host_b, full_size * sizeof( int), hipHostMallocDefault);
hipHostMalloc( & host_c, full_size * sizeof( int), hipHostMallocDefault);
int * dev_a, * dev_b, * dev_c;
hipMalloc( & dev_a, size * sizeof( int) );
hipMalloc( & dev_b, size * sizeof( int) );
hipMalloc( & dev_c, size * sizeof( int) );
std::minstd_rand generator;
std::uniform_int_distribution<> distribution(1, 6);
for ( int i = 0; i < full_size; ++i) {
host_a[i] = distribution( generator);
host_b[i] = distribution( generator);
}
for ( int i = 0; i < full_size; i += size) {
hipMemcpyAsync( dev_a, host_a + i, size * sizeof( int), hipMemcpyHostToDevice, stream);
hipMemcpyAsync( dev_b, host_b + i, size * sizeof( int), hipMemcpyHostToDevice, stream);
hipLaunchKernel( vector_add, dim3(size / 256), dim3(256), 0, stream, dev_a, dev_b, dev_c, size);
hipMemcpyAsync( host_c + i, dev_c, size * sizeof( int), hipMemcpyDeviceToHost, stream);
}
auto result = boost::fibers::hip::waitfor_all( stream);
BOOST_ASSERT( stream == std::get< 0 >( result) );
BOOST_ASSERT( hipSuccess == std::get< 1 >( result) );
std::cout << "f1: GPU computation finished" << std::endl;
hipHostFree( host_a);
hipHostFree( host_b);
hipHostFree( host_c);
hipFree( dev_a);
hipFree( dev_b);
hipFree( dev_c);
hipStreamDestroy( stream);
done = true;
} catch ( std::exception const& ex) {
std::cerr << "exception: " << ex.what() << std::endl;
}
std::cout << "f1: leaving" << std::endl;
});
boost::fibers::fiber f2([&done]{
std::cout << "f2: entered" << std::endl;
while ( ! done) {
std::cout << "f2: sleeping" << std::endl;
boost::this_fiber::sleep_for( std::chrono::milliseconds( 1 ) );
}
std::cout << "f2: leaving" << std::endl;
});
f1.join();
f2.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples | repos/fiber/examples/hip/multiple_streams.cpp |
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <random>
#include <tuple>
#include <hip/hip_runtime.h>
#include <boost/assert.hpp>
#include <boost/bind.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/fiber/all.hpp>
#include <boost/fiber/hip/waitfor.hpp>
__global__
void vector_add(hipLaunchParm lp, int * a, int * b, int * c, int size) {
int idx = threadIdx.x + blockIdx.x * blockDim.x;
if ( idx < size) {
c[idx] = a[idx] + b[idx];
}
}
int main() {
try {
bool done = false;
boost::fibers::fiber f1( [&done]{
std::cout << "f1: entered" << std::endl;
try {
hipStream_t stream0, stream1;
hipStreamCreate( & stream0);
hipStreamCreate( & stream1);
int size = 1024 * 1024;
int full_size = 20 * size;
int * host_a, * host_b, * host_c;
hipHostMalloc( & host_a, full_size * sizeof( int), hipHostMallocDefault);
hipHostMalloc( & host_b, full_size * sizeof( int), hipHostMallocDefault);
hipHostMalloc( & host_c, full_size * sizeof( int), hipHostMallocDefault);
int * dev_a0, * dev_b0, * dev_c0;
int * dev_a1, * dev_b1, * dev_c1;
hipMalloc( & dev_a0, size * sizeof( int) );
hipMalloc( & dev_b0, size * sizeof( int) );
hipMalloc( & dev_c0, size * sizeof( int) );
hipMalloc( & dev_a1, size * sizeof( int) );
hipMalloc( & dev_b1, size * sizeof( int) );
hipMalloc( & dev_c1, size * sizeof( int) );
std::minstd_rand generator;
std::uniform_int_distribution<> distribution(1, 6);
for ( int i = 0; i < full_size; ++i) {
host_a[i] = distribution( generator);
host_b[i] = distribution( generator);
}
for ( int i = 0; i < full_size; i += 2 * size) {
hipMemcpyAsync( dev_a0, host_a + i, size * sizeof( int), hipMemcpyHostToDevice, stream0);
hipMemcpyAsync( dev_a1, host_a + i + size, size * sizeof( int), hipMemcpyHostToDevice, stream1);
hipMemcpyAsync( dev_b0, host_b + i, size * sizeof( int), hipMemcpyHostToDevice, stream0);
hipMemcpyAsync( dev_b1, host_b + i + size, size * sizeof( int), hipMemcpyHostToDevice, stream1);
hipLaunchKernel( vector_add, dim3(size / 256), dim3(256), 0, stream0, dev_a0, dev_b0, dev_c0, size);
hipLaunchKernel( vector_add, dim3(size / 256), dim3(256), 0, stream1, dev_a1, dev_b1, dev_c1, size);
hipMemcpyAsync( host_c + i, dev_c0, size * sizeof( int), hipMemcpyDeviceToHost, stream0);
hipMemcpyAsync( host_c + i + size, dev_c1, size * sizeof( int), hipMemcpyDeviceToHost, stream1);
}
auto results = boost::fibers::hip::waitfor_all( stream0, stream1);
for ( auto & result : results) {
BOOST_ASSERT( stream0 == std::get< 0 >( result) || stream1 == std::get< 0 >( result) );
BOOST_ASSERT( hipSuccess == std::get< 1 >( result) );
}
std::cout << "f1: GPU computation finished" << std::endl;
hipHostFree( host_a);
hipHostFree( host_b);
hipHostFree( host_c);
hipFree( dev_a0);
hipFree( dev_b0);
hipFree( dev_c0);
hipFree( dev_a1);
hipFree( dev_b1);
hipFree( dev_c1);
hipStreamDestroy( stream0);
hipStreamDestroy( stream1);
done = true;
} catch ( std::exception const& ex) {
std::cerr << "exception: " << ex.what() << std::endl;
}
std::cout << "f1: leaving" << std::endl;
});
boost::fibers::fiber f2([&done]{
std::cout << "f2: entered" << std::endl;
while ( ! done) {
std::cout << "f2: sleeping" << std::endl;
boost::this_fiber::sleep_for( std::chrono::milliseconds( 1 ) );
}
std::cout << "f2: leaving" << std::endl;
});
f1.join();
f2.join();
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples | repos/fiber/examples/asio/round_robin.hpp | // Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FIBERS_ASIO_ROUND_ROBIN_H
#define BOOST_FIBERS_ASIO_ROUND_ROBIN_H
#include <chrono>
#include <cstddef>
#include <memory>
#include <mutex>
#include <queue>
#include <boost/asio.hpp>
#include <boost/assert.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/config.hpp>
#include <boost/fiber/condition_variable.hpp>
#include <boost/fiber/context.hpp>
#include <boost/fiber/mutex.hpp>
#include <boost/fiber/operations.hpp>
#include <boost/fiber/scheduler.hpp>
#include "yield.hpp"
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace asio {
class round_robin : public algo::algorithm {
private:
//[asio_rr_suspend_timer
std::shared_ptr< boost::asio::io_context > io_ctx_;
boost::asio::steady_timer suspend_timer_;
//]
boost::fibers::scheduler::ready_queue_type rqueue_{};
boost::fibers::mutex mtx_{};
boost::fibers::condition_variable cnd_{};
std::size_t counter_{ 0 };
public:
//[asio_rr_service_top
struct service : public boost::asio::io_context::service {
static boost::asio::io_context::id id;
std::unique_ptr< boost::asio::io_context::work > work_;
service( boost::asio::io_context & io_ctx) :
boost::asio::io_context::service( io_ctx),
work_{ new boost::asio::io_context::work( io_ctx) } {
}
virtual ~service() {}
service( service const&) = delete;
service & operator=( service const&) = delete;
void shutdown_service() override final {
work_.reset();
}
};
//]
//[asio_rr_ctor
round_robin( std::shared_ptr< boost::asio::io_context > const& io_ctx) :
io_ctx_( io_ctx),
suspend_timer_( * io_ctx_) {
// We use add_service() very deliberately. This will throw
// service_already_exists if you pass the same io_context instance to
// more than one round_robin instance.
boost::asio::add_service( * io_ctx_, new service( * io_ctx_) );
boost::asio::post( * io_ctx_, [this]() mutable {
//]
//[asio_rr_service_lambda
while ( ! io_ctx_->stopped() ) {
if ( has_ready_fibers() ) {
// run all pending handlers in round_robin
while ( io_ctx_->poll() );
// block this fiber till all pending (ready) fibers are processed
// == round_robin::suspend_until() has been called
std::unique_lock< boost::fibers::mutex > lk( mtx_);
cnd_.wait( lk);
} else {
// run one handler inside io_context
// if no handler available, block this thread
if ( ! io_ctx_->run_one() ) {
break;
}
}
}
//]
});
}
void awakened( context * ctx) noexcept {
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( ! ctx->ready_is_linked() );
ctx->ready_link( rqueue_); /*< fiber, enqueue on ready queue >*/
if ( ! ctx->is_context( boost::fibers::type::dispatcher_context) ) {
++counter_;
}
}
context * pick_next() noexcept {
context * ctx( nullptr);
if ( ! rqueue_.empty() ) { /*<
pop an item from the ready queue
>*/
ctx = & rqueue_.front();
rqueue_.pop_front();
BOOST_ASSERT( nullptr != ctx);
BOOST_ASSERT( context::active() != ctx);
if ( ! ctx->is_context( boost::fibers::type::dispatcher_context) ) {
--counter_;
}
}
return ctx;
}
bool has_ready_fibers() const noexcept {
return 0 < counter_;
}
//[asio_rr_suspend_until
void suspend_until( std::chrono::steady_clock::time_point const& abs_time) noexcept {
// Set a timer so at least one handler will eventually fire, causing
// run_one() to eventually return.
if ( (std::chrono::steady_clock::time_point::max)() != abs_time) {
// Each expires_at(time_point) call cancels any previous pending
// call. We could inadvertently spin like this:
// dispatcher calls suspend_until() with earliest wake time
// suspend_until() sets suspend_timer_
// lambda loop calls run_one()
// some other asio handler runs before timer expires
// run_one() returns to lambda loop
// lambda loop yields to dispatcher
// dispatcher finds no ready fibers
// dispatcher calls suspend_until() with SAME wake time
// suspend_until() sets suspend_timer_ to same time, canceling
// previous async_wait()
// lambda loop calls run_one()
// asio calls suspend_timer_ handler with operation_aborted
// run_one() returns to lambda loop... etc. etc.
// So only actually set the timer when we're passed a DIFFERENT
// abs_time value.
suspend_timer_.expires_at( abs_time);
suspend_timer_.async_wait([](boost::system::error_code const&){
this_fiber::yield();
});
}
cnd_.notify_one();
}
//]
//[asio_rr_notify
void notify() noexcept {
// Something has happened that should wake one or more fibers BEFORE
// suspend_timer_ expires. Reset the timer to cause it to fire
// immediately, causing the run_one() call to return. In theory we
// could use cancel() because we don't care whether suspend_timer_'s
// handler is called with operation_aborted or success. However --
// cancel() doesn't change the expiration time, and we use
// suspend_timer_'s expiration time to decide whether it's already
// set. If suspend_until() set some specific wake time, then notify()
// canceled it, then suspend_until() was called again with the same
// wake time, it would match suspend_timer_'s expiration time and we'd
// refrain from setting the timer. So instead of simply calling
// cancel(), reset the timer, which cancels the pending sleep AND sets
// a new expiration time. This will cause us to spin the loop twice --
// once for the operation_aborted handler, once for timer expiration
// -- but that shouldn't be a big problem.
suspend_timer_.async_wait([](boost::system::error_code const&){
this_fiber::yield();
});
suspend_timer_.expires_at( std::chrono::steady_clock::now() );
}
//]
};
boost::asio::io_context::id round_robin::service::id;
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_FIBERS_ASIO_ROUND_ROBIN_H
|
0 | repos/fiber/examples | repos/fiber/examples/asio/exchange.cpp | // Copyright Arnaud Kapp, Oliver Kowalke 2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <memory>
#include <thread>
#include <boost/asio.hpp>
#include <boost/fiber/all.hpp>
#include "round_robin.hpp"
std::shared_ptr< boost::fibers::unbuffered_channel< int > > c;
void foo() {
auto io_ptr = std::make_shared< boost::asio::io_context >();
boost::fibers::use_scheduling_algorithm< boost::fibers::asio::round_robin >( io_ptr);
boost::fibers::fiber([io_ptr](){
for ( int i = 0; i < 10; ++i) {
std::cout << "push " << i << std::endl;
c->push( i);
}
c->close();
io_ptr->stop();
}).detach();
io_ptr->run();
}
void bar() {
auto io_ptr = std::make_shared< boost::asio::io_context >();
boost::fibers::use_scheduling_algorithm< boost::fibers::asio::round_robin >( io_ptr);
boost::fibers::fiber([io_ptr](){
try {
for (;;) {
int i = c->value_pop();
std::cout << "pop " << i << std::endl;
}
} catch ( std::exception const& e) {
std::cout << "exception: " << e.what() << std::endl;
}
io_ptr->stop();
}).detach();
io_ptr->run();
}
int main() {
c = std::make_shared< boost::fibers::unbuffered_channel< int > >();
std::thread t1( foo);
std::thread t2( bar);
t2.join();
t1.join();
std::cout << "done." << std::endl;
return 0;
}
|
0 | repos/fiber/examples | repos/fiber/examples/asio/autoecho.cpp | // Copyright 2003-2013 Christopher M. Kohlhoff
// Copyright Oliver Kowalke, Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <sstream>
#include <thread>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/fiber/all.hpp>
#include "round_robin.hpp"
#include "yield.hpp"
using boost::asio::ip::tcp;
const int max_length = 1024;
typedef boost::shared_ptr< tcp::socket > socket_ptr;
const char* const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
/*****************************************************************************
* thread names
*****************************************************************************/
class ThreadNames {
private:
std::map<std::thread::id, std::string> names_{};
const char* next_{ alpha };
std::mutex mtx_{};
public:
ThreadNames() = default;
std::string lookup() {
std::unique_lock<std::mutex> lk( mtx_);
auto this_id( std::this_thread::get_id() );
auto found = names_.find( this_id );
if ( found != names_.end() ) {
return found->second;
}
BOOST_ASSERT( *next_);
std::string name(1, *next_++ );
names_[ this_id ] = name;
return name;
}
};
ThreadNames thread_names;
/*****************************************************************************
* fiber names
*****************************************************************************/
class FiberNames {
private:
std::map<boost::fibers::fiber::id, std::string> names_{};
unsigned next_{ 0 };
boost::fibers::mutex mtx_{};
public:
FiberNames() = default;
std::string lookup() {
std::unique_lock<boost::fibers::mutex> lk( mtx_);
auto this_id( boost::this_fiber::get_id() );
auto found = names_.find( this_id );
if ( found != names_.end() ) {
return found->second;
}
std::ostringstream out;
// Bake into the fiber's name the thread name on which we first
// lookup() its ID, to be able to spot when a fiber hops between
// threads.
out << thread_names.lookup() << next_++;
std::string name( out.str() );
names_[ this_id ] = name;
return name;
}
};
FiberNames fiber_names;
std::string tag() {
std::ostringstream out;
out << "Thread " << thread_names.lookup() << ": "
<< std::setw(4) << fiber_names.lookup() << std::setw(0);
return out.str();
}
/*****************************************************************************
* message printing
*****************************************************************************/
void print_( std::ostream& out) {
out << '\n';
}
template < typename T, typename... Ts >
void print_( std::ostream& out, T const& arg, Ts const&... args) {
out << arg;
print_(out, args...);
}
template < typename... T >
void print( T const&... args ) {
std::ostringstream buffer;
print_( buffer, args...);
std::cout << buffer.str() << std::flush;
}
/*****************************************************************************
* fiber function per server connection
*****************************************************************************/
void session( socket_ptr sock) {
try {
for (;;) {
char data[max_length];
boost::system::error_code ec;
std::size_t length = sock->async_read_some(
boost::asio::buffer( data),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
break; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
print( tag(), ": handled: ", std::string(data, length));
boost::asio::async_write(
* sock,
boost::asio::buffer( data, length),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
break; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
}
print( tag(), ": connection closed");
} catch ( std::exception const& ex) {
print( tag(), ": caught exception : ", ex.what());
}
}
/*****************************************************************************
* listening server
*****************************************************************************/
void server( std::shared_ptr< boost::asio::io_context > const& io_ctx, tcp::acceptor & a) {
print( tag(), ": echo-server started");
try {
for (;;) {
socket_ptr socket( new tcp::socket( * io_ctx) );
boost::system::error_code ec;
a.async_accept(
* socket,
boost::fibers::asio::yield[ec]);
if ( ec) {
throw boost::system::system_error( ec); //some other error
} else {
boost::fibers::fiber( session, socket).detach();
}
}
} catch ( std::exception const& ex) {
print( tag(), ": caught exception : ", ex.what());
}
io_ctx->stop();
print( tag(), ": echo-server stopped");
}
/*****************************************************************************
* fiber function per client
*****************************************************************************/
void client( std::shared_ptr< boost::asio::io_context > const& io_ctx, tcp::acceptor & a,
boost::fibers::barrier& barrier, unsigned iterations) {
print( tag(), ": echo-client started");
for (unsigned count = 0; count < iterations; ++count) {
tcp::resolver resolver( * io_ctx);
tcp::resolver::query query( tcp::v4(), "127.0.0.1", "9999");
tcp::resolver::iterator iterator = resolver.resolve( query);
tcp::socket s( * io_ctx);
boost::asio::connect( s, iterator);
for (unsigned msg = 0; msg < 1; ++msg) {
std::ostringstream msgbuf;
msgbuf << "from " << fiber_names.lookup() << " " << count << "." << msg;
std::string message(msgbuf.str());
print( tag(), ": Sending: ", message);
boost::system::error_code ec;
boost::asio::async_write(
s,
boost::asio::buffer( message),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
return; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
char reply[max_length];
size_t reply_length = s.async_read_some(
boost::asio::buffer( reply, max_length),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
return; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
print( tag(), ": Reply : ", std::string( reply, reply_length));
}
}
// done with all iterations, wait for rest of client fibers
if ( barrier.wait()) {
// exactly one barrier.wait() call returns true
// we're the lucky one
a.close();
print( tag(), ": acceptor stopped");
}
print( tag(), ": echo-client stopped");
}
/*****************************************************************************
* main
*****************************************************************************/
int main( int argc, char* argv[]) {
try {
//[asio_rr_setup
std::shared_ptr< boost::asio::io_context > io_ctx = std::make_shared< boost::asio::io_context >();
boost::fibers::use_scheduling_algorithm< boost::fibers::asio::round_robin >( io_ctx);
//]
print( "Thread ", thread_names.lookup(), ": started");
//[asio_rr_launch_fibers
// server
tcp::acceptor a( * io_ctx, tcp::endpoint( tcp::v4(), 9999) );
boost::fibers::fiber( server, io_ctx, std::ref( a) ).detach();
// client
const unsigned iterations = 2;
const unsigned clients = 3;
boost::fibers::barrier b( clients);
for ( unsigned i = 0; i < clients; ++i) {
boost::fibers::fiber(
client, io_ctx, std::ref( a), std::ref( b), iterations).detach();
}
//]
//[asio_rr_run
io_ctx->run();
//]
print( tag(), ": io_context returned");
print( "Thread ", thread_names.lookup(), ": stopping");
std::cout << "done." << std::endl;
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
print("Exception: ", e.what(), "\n");
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples | repos/fiber/examples/asio/yield.hpp | // Copyright 2003-2013 Christopher M. Kohlhoff
// Copyright Oliver Kowalke, Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FIBERS_ASIO_YIELD_HPP
#define BOOST_FIBERS_ASIO_YIELD_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace asio {
//[fibers_asio_yield_t
class yield_t {
public:
yield_t() = default;
/**
* @code
* static yield_t yield;
* boost::system::error_code myec;
* func(yield[myec]);
* @endcode
* @c yield[myec] returns an instance of @c yield_t whose @c ec_ points
* to @c myec. The expression @c yield[myec] "binds" @c myec to that
* (anonymous) @c yield_t instance, instructing @c func() to store any
* @c error_code it might produce into @c myec rather than throwing @c
* boost::system::system_error.
*/
yield_t operator[]( boost::system::error_code & ec) const {
yield_t tmp;
tmp.ec_ = & ec;
return tmp;
}
//private:
// ptr to bound error_code instance if any
boost::system::error_code * ec_{ nullptr };
};
//]
//[fibers_asio_yield
// canonical instance
thread_local yield_t yield{};
//]
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#include "detail/yield.hpp"
#endif // BOOST_FIBERS_ASIO_YIELD_HPP
|
0 | repos/fiber/examples/asio | repos/fiber/examples/asio/detail/yield.hpp | // Copyright Oliver Kowalke, Nat Goodspeed 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// modified for boost.asio >= 1.70
#ifndef BOOST_FIBERS_ASIO_DETAIL_YIELD_HPP
#define BOOST_FIBERS_ASIO_DETAIL_YIELD_HPP
#include <boost/asio/async_result.hpp>
#include <boost/asio/detail/config.hpp>
#include <boost/assert.hpp>
#include <boost/atomic.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/throw_exception.hpp>
#include <boost/fiber/all.hpp>
#include <mutex> // std::unique_lock
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace fibers {
namespace asio {
namespace detail {
//[fibers_asio_yield_completion
// Bundle a completion bool flag with a spinlock to protect it.
struct yield_completion {
enum state_t {
init,
waiting,
complete
};
typedef fibers::detail::spinlock mutex_t;
typedef std::unique_lock< mutex_t > lock_t;
typedef boost::intrusive_ptr< yield_completion > ptr_t;
std::atomic< std::size_t > use_count_{ 0 };
mutex_t mtx_{};
state_t state_{ init };
void wait() {
// yield_handler_base::operator()() will set state_ `complete` and
// attempt to wake a suspended fiber. It would be Bad if that call
// happened between our detecting (complete != state_) and suspending.
lock_t lk{ mtx_ };
// If state_ is already set, we're done here: don't suspend.
if ( complete != state_) {
state_ = waiting;
// suspend(unique_lock<spinlock>) unlocks the lock in the act of
// resuming another fiber
fibers::context::active()->suspend( lk);
}
}
friend void intrusive_ptr_add_ref( yield_completion * yc) noexcept {
BOOST_ASSERT( nullptr != yc);
yc->use_count_.fetch_add( 1, std::memory_order_relaxed);
}
friend void intrusive_ptr_release( yield_completion * yc) noexcept {
BOOST_ASSERT( nullptr != yc);
if ( 1 == yc->use_count_.fetch_sub( 1, std::memory_order_release) ) {
std::atomic_thread_fence( std::memory_order_acquire);
delete yc;
}
}
};
//]
//[fibers_asio_yield_handler_base
// This class encapsulates common elements between yield_handler<T> (capturing
// a value to return from asio async function) and yield_handler<void> (no
// such value). See yield_handler<T> and its <void> specialization below. Both
// yield_handler<T> and yield_handler<void> are passed by value through
// various layers of asio functions. In other words, they're potentially
// copied multiple times. So key data such as the yield_completion instance
// must be stored in our async_result<yield_handler<>> specialization, which
// should be instantiated only once.
class yield_handler_base {
public:
yield_handler_base( yield_t const& y) :
// capture the context* associated with the running fiber
ctx_{ boost::fibers::context::active() },
// capture the passed yield_t
yt_( y ) {
}
// completion callback passing only (error_code)
void operator()( boost::system::error_code const& ec) {
BOOST_ASSERT_MSG( ycomp_,
"Must inject yield_completion* "
"before calling yield_handler_base::operator()()");
BOOST_ASSERT_MSG( yt_.ec_,
"Must inject boost::system::error_code* "
"before calling yield_handler_base::operator()()");
// If originating fiber is busy testing state_ flag, wait until it
// has observed (completed != state_).
yield_completion::lock_t lk{ ycomp_->mtx_ };
yield_completion::state_t state = ycomp_->state_;
// Notify a subsequent yield_completion::wait() call that it need not
// suspend.
ycomp_->state_ = yield_completion::complete;
// set the error_code bound by yield_t
* yt_.ec_ = ec;
// unlock the lock that protects state_
lk.unlock();
// If ctx_ is still active, e.g. because the async operation
// immediately called its callback (this method!) before the asio
// async function called async_result_base::get(), we must not set it
// ready.
if ( yield_completion::waiting == state) {
// wake the fiber
fibers::context::active()->schedule( ctx_);
}
}
//private:
boost::fibers::context * ctx_;
yield_t yt_;
// We depend on this pointer to yield_completion, which will be injected
// by async_result.
yield_completion::ptr_t ycomp_{};
};
//]
//[fibers_asio_yield_handler_T
// asio uses handler_type<completion token type, signature>::type to decide
// what to instantiate as the actual handler. Below, we specialize
// handler_type< yield_t, ... > to indicate yield_handler<>. So when you pass
// an instance of yield_t as an asio completion token, asio selects
// yield_handler<> as the actual handler class.
template< typename T >
class yield_handler: public yield_handler_base {
public:
// asio passes the completion token to the handler constructor
explicit yield_handler( yield_t const& y) :
yield_handler_base{ y } {
}
// completion callback passing only value (T)
void operator()( T t) {
// just like callback passing success error_code
(*this)( boost::system::error_code(), std::move(t) );
}
// completion callback passing (error_code, T)
void operator()( boost::system::error_code const& ec, T t) {
BOOST_ASSERT_MSG( value_,
"Must inject value ptr "
"before caling yield_handler<T>::operator()()");
// move the value to async_result<> instance BEFORE waking up a
// suspended fiber
* value_ = std::move( t);
// forward the call to base-class completion handler
yield_handler_base::operator()( ec);
}
//private:
// pointer to destination for eventual value
// this must be injected by async_result before operator()() is called
T * value_{ nullptr };
};
//]
//[fibers_asio_yield_handler_void
// yield_handler<void> is like yield_handler<T> without value_. In fact it's
// just like yield_handler_base.
template<>
class yield_handler< void >: public yield_handler_base {
public:
explicit yield_handler( yield_t const& y) :
yield_handler_base{ y } {
}
// nullary completion callback
void operator()() {
( * this)( boost::system::error_code() );
}
// inherit operator()(error_code) overload from base class
using yield_handler_base::operator();
};
//]
// Specialize asio_handler_invoke hook to ensure that any exceptions thrown
// from the handler are propagated back to the caller
template< typename Fn, typename T >
void asio_handler_invoke( Fn&& fn, yield_handler< T > *) {
fn();
}
//[fibers_asio_async_result_base
// Factor out commonality between async_result<yield_handler<T>> and
// async_result<yield_handler<void>>
class async_result_base {
public:
explicit async_result_base( yield_handler_base & h) :
ycomp_{ new yield_completion{} } {
// Inject ptr to our yield_completion instance into this
// yield_handler<>.
h.ycomp_ = this->ycomp_;
// if yield_t didn't bind an error_code, make yield_handler_base's
// error_code* point to an error_code local to this object so
// yield_handler_base::operator() can unconditionally store through
// its error_code*
if ( ! h.yt_.ec_) {
h.yt_.ec_ = & ec_;
}
}
void get() {
// Unless yield_handler_base::operator() has already been called,
// suspend the calling fiber until that call.
ycomp_->wait();
// The only way our own ec_ member could have a non-default value is
// if our yield_handler did not have a bound error_code AND the
// completion callback passed a non-default error_code.
if ( ec_) {
throw_exception( boost::system::system_error{ ec_ } );
}
}
private:
// If yield_t does not bind an error_code instance, store into here.
boost::system::error_code ec_{};
yield_completion::ptr_t ycomp_;
};
//]
}}}}
namespace boost {
namespace asio {
//[fibers_asio_async_result_T
// asio constructs an async_result<> instance from the yield_handler specified
// by handler_type<>::type. A particular asio async method constructs the
// yield_handler, constructs this async_result specialization from it, then
// returns the result of calling its get() method.
template< typename ReturnType, typename T >
class async_result< boost::fibers::asio::yield_t, ReturnType(boost::system::error_code, T) > :
public boost::fibers::asio::detail::async_result_base {
public:
// type returned by get()
using return_type = T;
using completion_handler_type = fibers::asio::detail::yield_handler<T>;
explicit async_result( boost::fibers::asio::detail::yield_handler< T > & h) :
boost::fibers::asio::detail::async_result_base{ h } {
// Inject ptr to our value_ member into yield_handler<>: result will
// be stored here.
h.value_ = & value_;
}
// asio async method returns result of calling get()
return_type get() {
boost::fibers::asio::detail::async_result_base::get();
return std::move( value_);
}
private:
return_type value_{};
};
//]
//[fibers_asio_async_result_void
// Without the need to handle a passed value, our yield_handler<void>
// specialization is just like async_result_base.
template<>
class async_result< boost::fibers::asio::yield_t, void(boost::system::error_code) > :
public boost::fibers::asio::detail::async_result_base {
public:
using return_type = void;
using completion_handler_type = fibers::asio::detail::yield_handler<void>;
explicit async_result( boost::fibers::asio::detail::yield_handler< void > & h):
boost::fibers::asio::detail::async_result_base{ h } {
}
};
//]
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_FIBERS_ASIO_DETAIL_YIELD_HPP
|
0 | repos/fiber/examples/asio | repos/fiber/examples/asio/ps/publisher.cpp | //
// blocking_tcp_echo_client.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <boost/asio.hpp>
using boost::asio::ip::tcp;
enum {
max_length = 1024
};
int main( int argc, char* argv[]) {
try {
if ( 3 != argc) {
std::cerr << "Usage: publisher <host> <queue>\n";
return EXIT_FAILURE;
}
boost::asio::io_context io_context;
tcp::resolver resolver( io_context);
tcp::resolver::query query( tcp::v4(), argv[1], "9997");
tcp::resolver::iterator iterator = resolver.resolve(query);
tcp::socket s( io_context);
boost::asio::connect( s, iterator);
char msg[max_length];
std::string queue( argv[2]);
std::memset( msg, '\0', max_length);
std::memcpy( msg, queue.c_str(), queue.size() );
boost::asio::write( s, boost::asio::buffer( msg, max_length) );
for (;;) {
std::cout << "publish: ";
char request[max_length];
std::cin.getline( request, max_length);
boost::asio::write( s, boost::asio::buffer( request, max_length) );
}
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "Exception: " << e.what() << "\n";
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples/asio | repos/fiber/examples/asio/ps/subscriber.cpp | //
// blocking_tcp_echo_client.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <boost/asio.hpp>
using boost::asio::ip::tcp;
enum {
max_length = 1024
};
int main( int argc, char* argv[]) {
try {
if ( 3 != argc) {
std::cerr << "Usage: subscriber <host> <queue>\n";
return EXIT_FAILURE;
}
boost::asio::io_context io_context;
tcp::resolver resolver( io_context);
tcp::resolver::query query( tcp::v4(), argv[1], "9998");
tcp::resolver::iterator iterator = resolver.resolve( query);
tcp::socket s( io_context);
boost::asio::connect( s, iterator);
char msg[max_length];
std::string queue( argv[2]);
std::memset( msg, '\0', max_length);
std::memcpy( msg, queue.c_str(), queue.size() );
boost::asio::write( s, boost::asio::buffer( msg, max_length) );
for (;;) {
char reply[max_length];
size_t reply_length = s.read_some( boost::asio::buffer( reply, max_length) );
std::cout << "published: ";
std::cout.write( reply, reply_length);
std::cout << std::endl;
}
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "Exception: " << e.what() << "\n";
}
return EXIT_FAILURE;
}
|
0 | repos/fiber/examples/asio | repos/fiber/examples/asio/ps/server.cpp | // Copyright Oliver Kowalke 2015.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cstddef>
#include <cstdlib>
#include <map>
#include <memory>
#include <set>
#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/fiber/all.hpp>
#include "../round_robin.hpp"
#include "../yield.hpp"
using boost::asio::ip::tcp;
const std::size_t max_length = 1024;
class subscriber_session;
typedef std::shared_ptr< subscriber_session > subscriber_session_ptr;
// a queue has n subscribers (subscriptions)
// this class holds a list of subcribers for one queue
class subscriptions {
public:
~subscriptions();
// subscribe to this queue
void subscribe( subscriber_session_ptr const& s) {
subscribers_.insert( s);
}
// unsubscribe from this queue
void unsubscribe( subscriber_session_ptr const& s) {
subscribers_.erase(s);
}
// publish a message, e.g. push this message to all subscribers
void publish( std::string const& msg);
private:
// list of subscribers
std::set< subscriber_session_ptr > subscribers_;
};
// a class to register queues and to subsribe clients to this queues
class registry : private boost::noncopyable {
private:
typedef std::map< std::string, std::shared_ptr< subscriptions > > queues_cont;
typedef queues_cont::iterator queues_iter;
boost::fibers::mutex mtx_;
queues_cont queues_;
void register_queue_( std::string const& queue) {
if ( queues_.end() != queues_.find( queue) ) {
throw std::runtime_error("queue already exists");
}
queues_[queue] = std::make_shared< subscriptions >();
std::cout << "new queue '" << queue << "' registered" << std::endl;
}
void unregister_queue_( std::string const& queue) {
queues_.erase( queue);
std::cout << "queue '" << queue << "' unregistered" << std::endl;
}
void subscribe_( std::string const& queue, subscriber_session_ptr s) {
queues_iter iter = queues_.find( queue);
if ( queues_.end() == iter ) {
throw std::runtime_error("queue does not exist");
}
iter->second->subscribe( s);
std::cout << "new subscription to queue '" << queue << "'" << std::endl;
}
void unsubscribe_( std::string const& queue, subscriber_session_ptr s) {
queues_iter iter = queues_.find( queue);
if ( queues_.end() != iter ) {
iter->second->unsubscribe( s);
}
}
void publish_( std::string const& queue, std::string const& msg) {
queues_iter iter = queues_.find( queue);
if ( queues_.end() == iter ) {
throw std::runtime_error("queue does not exist");
}
iter->second->publish( msg);
std::cout << "message '" << msg << "' to publish on queue '" << queue << "'" << std::endl;
}
public:
// add a queue to registry
void register_queue( std::string const& queue) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
register_queue_( queue);
}
// remove a queue from registry
void unregister_queue( std::string const& queue) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
unregister_queue_( queue);
}
// subscribe to a queue
void subscribe( std::string const& queue, subscriber_session_ptr s) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
subscribe_( queue, s);
}
// unsubscribe from a queue
void unsubscribe( std::string const& queue, subscriber_session_ptr s) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
unsubscribe_( queue, s);
}
// publish a message to all subscribers registerd to the queue
void publish( std::string const& queue, std::string const& msg) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
publish_( queue, msg);
}
};
// a subscriber subscribes to a given queue in order to receive messages published on this queue
class subscriber_session : public std::enable_shared_from_this< subscriber_session > {
public:
explicit subscriber_session( std::shared_ptr< boost::asio::io_context > const& io_context, registry & reg) :
socket_( * io_context),
reg_( reg) {
}
tcp::socket& socket() {
return socket_;
}
// this function is executed inside the fiber
void run() {
std::string queue;
try {
boost::system::error_code ec;
// read first message == queue name
// async_ready() returns if the the complete message is read
// until this the fiber is suspended until the complete message
// is read int the given buffer 'data'
boost::asio::async_read(
socket_,
boost::asio::buffer( data_),
boost::fibers::asio::yield[ec]);
if ( ec) {
throw std::runtime_error("no queue from subscriber");
}
// first message ist equal to the queue name the publisher
// publishes to
queue = data_;
// subscribe to new queue
reg_.subscribe( queue, shared_from_this() );
// read published messages
for (;;) {
// wait for a conditon-variable for new messages
// the fiber will be suspended until the condtion
// becomes true and the fiber is resumed
// published message is stored in buffer 'data_'
std::unique_lock< boost::fibers::mutex > lk( mtx_);
cond_.wait( lk);
std::string data( data_);
lk.unlock();
// message '<fini>' terminates subscription
if ( "<fini>" == data) {
break;
}
// async. write message to socket connected with
// subscriber
// async_write() returns if the complete message was writen
// the fiber is suspended in the meanwhile
boost::asio::async_write(
socket_,
boost::asio::buffer( data, data.size() ),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
break; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
std::cout << "subscriber::run(): '" << data << "' written" << std::endl;
}
} catch ( std::exception const& e) {
std::cerr << "subscriber [" << queue << "] failed: " << e.what() << std::endl;
}
// close socket
socket_.close();
// unregister queue
reg_.unsubscribe( queue, shared_from_this() );
}
// called from publisher_session (running in other fiber)
void publish( std::string const& msg) {
std::unique_lock< boost::fibers::mutex > lk( mtx_);
std::memset( data_, '\0', sizeof( data_));
std::memcpy( data_, msg.c_str(), (std::min)(max_length, msg.size()));
cond_.notify_one();
}
private:
tcp::socket socket_;
registry & reg_;
boost::fibers::mutex mtx_;
boost::fibers::condition_variable cond_;
// fixed size message
char data_[max_length];
};
subscriptions::~subscriptions() {
for ( subscriber_session_ptr s : subscribers_) {
s->publish("<fini>");
}
}
void
subscriptions::publish( std::string const& msg) {
for ( subscriber_session_ptr s : subscribers_) {
s->publish( msg);
}
}
// a publisher publishes messages on its queue
// subscriber might register to this queue to get the published messages
class publisher_session : public std::enable_shared_from_this< publisher_session > {
public:
explicit publisher_session( std::shared_ptr< boost::asio::io_context > const& io_context, registry & reg) :
socket_( * io_context),
reg_( reg) {
}
tcp::socket& socket() {
return socket_;
}
// this function is executed inside the fiber
void run() {
std::string queue;
try {
boost::system::error_code ec;
// fixed size message
char data[max_length];
// read first message == queue name
// async_ready() returns if the the complete message is read
// until this the fiber is suspended until the complete message
// is read int the given buffer 'data'
boost::asio::async_read(
socket_,
boost::asio::buffer( data),
boost::fibers::asio::yield[ec]);
if ( ec) {
throw std::runtime_error("no queue from publisher");
}
// first message ist equal to the queue name the publisher
// publishes to
queue = data;
// register the new queue
reg_.register_queue( queue);
// start publishing messages
for (;;) {
// read message from publisher asyncronous
// async_read() suspends this fiber until the complete emssage is read
// and stored in the given buffer 'data'
boost::asio::async_read(
socket_,
boost::asio::buffer( data),
boost::fibers::asio::yield[ec]);
if ( ec == boost::asio::error::eof) {
break; //connection closed cleanly by peer
} else if ( ec) {
throw boost::system::system_error( ec); //some other error
}
// publish message to all subscribers
reg_.publish( queue, std::string( data) );
}
} catch ( std::exception const& e) {
std::cerr << "publisher [" << queue << "] failed: " << e.what() << std::endl;
}
// close socket
socket_.close();
// unregister queue
reg_.unregister_queue( queue);
}
private:
tcp::socket socket_;
registry & reg_;
};
typedef std::shared_ptr< publisher_session > publisher_session_ptr;
// function accepts connections requests from clients acting as a publisher
void accept_publisher( std::shared_ptr< boost::asio::io_context > const& io_context,
unsigned short port,
registry & reg) {
// create TCP-acceptor
tcp::acceptor acceptor( * io_context, tcp::endpoint( tcp::v4(), port) );
// loop for accepting connection requests
for (;;) {
boost::system::error_code ec;
// create new publisher-session
// this instance will be associated with one publisher
publisher_session_ptr new_publisher_session =
std::make_shared< publisher_session >( io_context, std::ref( reg) );
// async. accept of new connection request
// this function will suspend this execution context (fiber) until a
// connection was established, after returning from this function a new client (publisher)
// is connected
acceptor.async_accept(
new_publisher_session->socket(),
boost::fibers::asio::yield[ec]);
if ( ! ec) {
// run the new publisher in its own fiber (one fiber for one client)
boost::fibers::fiber(
std::bind( & publisher_session::run, new_publisher_session) ).detach();
}
}
}
// function accepts connections requests from clients acting as a subscriber
void accept_subscriber( std::shared_ptr< boost::asio::io_context > const& io_context,
unsigned short port,
registry & reg) {
// create TCP-acceptor
tcp::acceptor acceptor( * io_context, tcp::endpoint( tcp::v4(), port) );
// loop for accepting connection requests
for (;;) {
boost::system::error_code ec;
// create new subscriber-session
// this instance will be associated with one subscriber
subscriber_session_ptr new_subscriber_session =
std::make_shared< subscriber_session >( io_context, std::ref( reg) );
// async. accept of new connection request
// this function will suspend this execution context (fiber) until a
// connection was established, after returning from this function a new client (subscriber)
// is connected
acceptor.async_accept(
new_subscriber_session->socket(),
boost::fibers::asio::yield[ec]);
if ( ! ec) {
// run the new subscriber in its own fiber (one fiber for one client)
boost::fibers::fiber(
std::bind( & subscriber_session::run, new_subscriber_session) ).detach();
}
}
}
int main( int argc, char* argv[]) {
try {
// create io_context for async. I/O
std::shared_ptr< boost::asio::io_context > io_context = std::make_shared< boost::asio::io_context >();
// register asio scheduler
boost::fibers::use_scheduling_algorithm< boost::fibers::asio::round_robin >( io_context);
// registry for queues and its subscription
registry reg;
// create an acceptor for publishers, run it as fiber
boost::fibers::fiber(
accept_publisher, std::ref( io_context), 9997, std::ref( reg) ).detach();
// create an acceptor for subscribers, run it as fiber
boost::fibers::fiber(
accept_subscriber, std::ref( io_context), 9998, std::ref( reg) ).detach();
// dispatch
io_context->run();
return EXIT_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "Exception: " << e.what() << "\n";
}
return EXIT_FAILURE;
}
|
0 | repos/fiber | repos/fiber/meta/libraries.json | {
"key": "fiber",
"name": "Fiber",
"authors": [
"Oliver Kowalke"
],
"description": "(C++11) Userland threads library.",
"category": [
"Concurrent",
"System"
],
"maintainers": [
"Oliver Kowalke <oliver.kowalke -at- gmail.com>"
],
"cxxstd": "11"
}
|
0 | repos/fiber | repos/fiber/test/test_promise_dispatch.cpp | // (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int gi = 7;
struct my_exception : public std::runtime_error {
my_exception() :
std::runtime_error("my_exception") {
}
};
struct A {
A() = default;
A( A const&) = delete;
A( A &&) = default;
A & operator=( A const&) = delete;
A & operator=( A &&) = default;
int value{ 0 };
};
void fn1( boost::fibers::promise< int > * p, int i) {
boost::this_fiber::yield();
p->set_value( i);
}
void fn2() {
boost::fibers::promise< int > p;
boost::fibers::future< int > f( p.get_future() );
boost::this_fiber::yield();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn1, & p, 7).detach();
boost::this_fiber::yield();
BOOST_CHECK( 7 == f.get() );
}
int fn3() {
return 3;
}
void fn4() {
}
int fn5() {
boost::throw_exception( my_exception() );
return 3;
}
void fn6() {
boost::throw_exception( my_exception() );
}
int & fn7() {
return gi;
}
int fn8( int i) {
return i;
}
A fn9() {
A a;
a.value = 3;
return a;
}
A fn10() {
boost::throw_exception( my_exception() );
return A();
}
// promise
void test_promise_create() {
// use std::allocator<> as default
boost::fibers::promise< int > p1;
// use std::allocator<> as user defined
std::allocator< boost::fibers::promise< int > > alloc;
boost::fibers::promise< int > p2( std::allocator_arg, alloc);
}
void test_promise_create_ref() {
// use std::allocator<> as default
boost::fibers::promise< int& > p1;
// use std::allocator<> as user defined
std::allocator< boost::fibers::promise< int& > > alloc;
boost::fibers::promise< int& > p2( std::allocator_arg, alloc);
}
void test_promise_create_void() {
// use std::allocator<> as default
boost::fibers::promise< void > p1;
// use std::allocator<> as user defined
std::allocator< boost::fibers::promise< void > > alloc;
boost::fibers::promise< void > p2( std::allocator_arg, alloc);
}
void test_promise_move() {
boost::fibers::promise< int > p1;
// move construction
boost::fibers::promise< int > p2( std::move( p1) );
// move assigment
p1 = std::move( p2);
}
void test_promise_move_ref() {
boost::fibers::promise< int& > p1;
// move construction
boost::fibers::promise< int& > p2( std::move( p1) );
// move assigment
p1 = std::move( p2);
}
void test_promise_move_void() {
boost::fibers::promise< void > p1;
// move construction
boost::fibers::promise< void > p2( std::move( p1) );
// move assigment
p1 = std::move( p2);
}
void test_promise_swap() {
boost::fibers::promise< int > p1;
// move construction
boost::fibers::promise< int > p2( std::move( p1) );
// swap
p1.swap( p2);
}
void test_promise_swap_ref() {
boost::fibers::promise< int& > p1;
// move construction
boost::fibers::promise< int& > p2( std::move( p1) );
// swap
p1.swap( p2);
}
void test_promise_swap_void() {
boost::fibers::promise< void > p1;
// move construction
boost::fibers::promise< void > p2( std::move( p1) );
// swap
p1.swap( p2);
}
void test_promise_get_future() {
boost::fibers::promise< int > p1;
// retrieve future
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::promise< int > p2( std::move( p1) );
// retrieve future from uninitialized
thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::promise_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_get_future_ref() {
boost::fibers::promise< int& > p1;
// retrieve future
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::promise< int& > p2( std::move( p1) );
// retrieve future from uninitialized
thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::promise_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_get_future_void() {
boost::fibers::promise< void > p1;
// retrieve future
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::promise< void > p2( std::move( p1) );
// retrieve future from uninitialized
thrown = false;
try {
f1 = p1.get_future();
} catch ( boost::fibers::promise_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_value() {
// promise takes a copyable as return type
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// copy value
p1.set_value( 7);
BOOST_CHECK( 7 == f1.get() );
// set value a second time
bool thrown = false;
try {
p1.set_value( 11);
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_value_move() {
// promise takes a copyable as return type
boost::fibers::promise< A > p1;
boost::fibers::future< A > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// move value
A a1; a1.value = 7;
p1.set_value( std::move( a1) );
A a2 = f1.get();
BOOST_CHECK( 7 == a2.value);
// set value a second time
bool thrown = false;
try {
A a;
p1.set_value( std::move( a) );
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_value_ref() {
// promise takes a reference as return type
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// copy value
int i = 7;
p1.set_value( i);
int & j = f1.get();
BOOST_CHECK( &i == &j);
// set value a second time
bool thrown = false;
try {
p1.set_value( i);
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_value_void() {
// promise takes a copyable as return type
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// set void
p1.set_value();
f1.get();
// set value a second time
bool thrown = false;
try {
p1.set_value();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_exception() {
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
p1.set_exception( std::make_exception_ptr( my_exception() ) );
// set exception a second time
bool thrown = false;
try {
p1.set_exception( std::make_exception_ptr( my_exception() ) );
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// set value
thrown = false;
try
{ p1.set_value( 11); }
catch ( boost::fibers::promise_already_satisfied const&)
{ thrown = true; }
BOOST_CHECK( thrown);
}
void test_promise_set_exception_ref() {
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
p1.set_exception( std::make_exception_ptr( my_exception() ) );
// set exception a second time
bool thrown = false;
try {
p1.set_exception( std::make_exception_ptr( my_exception() ) );
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// set value
thrown = false;
int i = 11;
try {
p1.set_value( i);
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_promise_set_exception_void() {
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
p1.set_exception( std::make_exception_ptr( my_exception() ) );
// set exception a second time
bool thrown = false;
try {
p1.set_exception( std::make_exception_ptr( my_exception() ) );
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// set value
thrown = false;
try {
p1.set_value();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: promise test suite");
test->add(BOOST_TEST_CASE(test_promise_create));
test->add(BOOST_TEST_CASE(test_promise_create_ref));
test->add(BOOST_TEST_CASE(test_promise_create_void));
test->add(BOOST_TEST_CASE(test_promise_move));
test->add(BOOST_TEST_CASE(test_promise_move_ref));
test->add(BOOST_TEST_CASE(test_promise_move_void));
test->add(BOOST_TEST_CASE(test_promise_swap));
test->add(BOOST_TEST_CASE(test_promise_swap_ref));
test->add(BOOST_TEST_CASE(test_promise_swap_void));
test->add(BOOST_TEST_CASE(test_promise_get_future));
test->add(BOOST_TEST_CASE(test_promise_get_future_ref));
test->add(BOOST_TEST_CASE(test_promise_get_future_void));
test->add(BOOST_TEST_CASE(test_promise_set_value));
test->add(BOOST_TEST_CASE(test_promise_set_value_move));
test->add(BOOST_TEST_CASE(test_promise_set_value_ref));
test->add(BOOST_TEST_CASE(test_promise_set_value_void));
test->add(BOOST_TEST_CASE(test_promise_set_exception));
test->add(BOOST_TEST_CASE(test_promise_set_exception_ref));
test->add(BOOST_TEST_CASE(test_promise_set_exception_void));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_mutex_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
int value2 = 0;
template< typename M >
void fn1( M & mtx) {
typedef M mutex_type;
typename std::unique_lock< mutex_type > lk( mtx);
++value1;
for ( int i = 0; i < 3; ++i)
boost::this_fiber::yield();
}
template< typename M >
void fn2( M & mtx) {
typedef M mutex_type;
++value2;
typename std::unique_lock< mutex_type > lk( mtx);
++value2;
}
void fn3( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(2500000)+ms(2000)); // within 2.5 ms
}
void fn4( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while ( ! m.try_lock() );
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
void fn5( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK( m.try_lock_for(ms(300)+ms(2000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn6( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn7( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(300) + ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5ms
}
void fn8( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
ns r = ns(5000000)+ms(2000); // within 6ms
BOOST_CHECK(d < r); // within 6ms
}
void fn9( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.lock();
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(2500)+ms(2000)); // within 2.5 ms
}
void fn10( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock()) ;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
void fn11( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(300)+ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn12( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(5000)+ms(2000)); // within 5 ms
}
void fn13( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(300) + ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn14( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn15( boost::fibers::recursive_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.lock();
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(2500000)+ms(2000)); // within 2.5 ms
}
void fn16( boost::fibers::recursive_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock());
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
void fn17( boost::fibers::mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(2500000)+ms(2000)); // within 2.5 ms
}
void fn18( boost::fibers::mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock()) ;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
template< typename M >
struct test_lock {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
mutex_type mtx;
// Test the lock's constructors.
{
lock_type lk(mtx, std::defer_lock);
BOOST_CHECK(!lk);
}
lock_type lk(mtx);
BOOST_CHECK(lk ? true : false);
// Test the lock and unlock methods.
lk.unlock();
BOOST_CHECK(!lk);
lk.lock();
BOOST_CHECK(lk ? true : false);
}
};
template< typename M >
struct test_exclusive {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
value1 = 0;
value2 = 0;
BOOST_CHECK_EQUAL( 0, value1);
BOOST_CHECK_EQUAL( 0, value2);
mutex_type mtx;
boost::fibers::fiber f1( boost::fibers::launch::post, & fn1< mutex_type >, std::ref( mtx) );
boost::fibers::fiber f2( boost::fibers::launch::post, & fn2< mutex_type >, std::ref( mtx) );
BOOST_ASSERT( f1.joinable() );
BOOST_ASSERT( f2.joinable() );
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
BOOST_CHECK_EQUAL( 2, value2);
}
};
template< typename M >
struct test_recursive_lock {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
mutex_type mx;
lock_type lock1(mx);
lock_type lock2(mx);
}
};
void do_test_mutex() {
test_lock< boost::fibers::mutex >()();
test_exclusive< boost::fibers::mutex >()();
{
boost::fibers::mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn17, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
{
boost::fibers::mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn18, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
}
void test_mutex() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_mutex).join();
}
void do_test_recursive_mutex() {
test_lock< boost::fibers::recursive_mutex >()();
test_exclusive< boost::fibers::recursive_mutex >()();
test_recursive_lock< boost::fibers::recursive_mutex >()();
{
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn15, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
{
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn16, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
}
void test_recursive_mutex() {
boost::fibers::fiber( boost::fibers::launch::post, do_test_recursive_mutex).join();
}
void do_test_timed_mutex() {
test_lock< boost::fibers::timed_mutex >()();
test_exclusive< boost::fibers::timed_mutex >()();
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn3, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn4, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn5, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn6, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn7, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn8, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) + ms(1000) );
timed_mtx.unlock();
f.join();
}
}
void test_timed_mutex() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_timed_mutex).join();
}
void do_test_recursive_timed_mutex() {
test_lock< boost::fibers::recursive_timed_mutex >()();
test_exclusive< boost::fibers::recursive_timed_mutex >()();
test_recursive_lock< boost::fibers::recursive_timed_mutex >()();
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn9, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn10, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn11, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn12, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(400) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn13, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn14, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) );
timed_mtx.unlock();
f.join();
}
}
void test_recursive_timed_mutex() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_recursive_timed_mutex).join();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: mutex test suite");
test->add( BOOST_TEST_CASE( & test_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_mutex) );
test->add( BOOST_TEST_CASE( & test_timed_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_timed_mutex) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_variable_any_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <map>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
inline
std::chrono::system_clock::time_point delay(int secs, int msecs = 0, int /*nsecs*/ = 0) {
std::chrono::system_clock::time_point t = std::chrono::system_clock::now();
t += std::chrono::seconds( secs);
t += std::chrono::milliseconds( msecs);
//t += std::chrono::nanoseconds( nsecs);
return t;
}
struct condition_test_data {
condition_test_data() : notified(0), awoken(0) { }
boost::fibers::mutex mutex;
boost::fibers::condition_variable_any cond;
int notified;
int awoken;
};
void condition_test_fiber(condition_test_data* data) {
try {
data->mutex.lock();
while (!(data->notified > 0))
data->cond.wait(data->mutex);
data->awoken++;
} catch ( ... ) {
}
data->mutex.unlock();
}
struct cond_predicate {
cond_predicate(int& var, int val) : _var(var), _val(val) { }
bool operator()() { return _var == _val; }
int& _var;
int _val;
private:
void operator=(cond_predicate&);
};
void notify_one_fn( boost::fibers::condition_variable_any & cond) {
cond.notify_one();
}
void notify_all_fn( boost::fibers::condition_variable_any & cond) {
cond.notify_all();
}
void wait_fn(
boost::fibers::mutex & mtx,
boost::fibers::condition_variable_any & cond) {
mtx.lock();
cond.wait( mtx);
++value1;
mtx.unlock();
}
void test_one_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
}
void test_two_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 1, value1);
f1.join();
f2.join();
f3.join();
f4.join();
BOOST_CHECK_EQUAL( 2, value1);
}
void test_two_waiter_notify_all() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::dispatch,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 2, value1);
boost::fibers::fiber f5(
boost::fibers::launch::dispatch,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 2, value1);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
BOOST_CHECK_EQUAL( 3, value1);
}
int test1 = 0;
int test2 = 0;
int runs = 0;
void fn1( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0) {
cv.wait(m);
}
BOOST_CHECK(test2 != 0);
m.unlock();
}
void fn2( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::system_clock::time_point t0 = std::chrono::system_clock::now();
std::chrono::system_clock::time_point t = t0 + ms(250);
int count=0;
while (test2 == 0 && cv.wait_until(m, t) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
class Pred {
int & i_;
public:
explicit Pred(int& i) :
i_(i)
{}
bool operator()()
{ return i_ != 0; }
};
void fn3( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point t = t0 + ms(250);
bool r = cv.wait_until(m, t, Pred(test2));
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
BOOST_CHECK(r);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(250+100));
BOOST_CHECK(test2 == 0);
BOOST_CHECK(!r);
}
++runs;
m.unlock();
}
void fn4( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
while (test2 == 0 && cv.wait_for(m, ms(250)) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
void fn5( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
cv.wait_for(m, ms(250), Pred(test2));
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250+1000));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
void do_test_condition_wait() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn1, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
void test_condition_wait() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait).join();
do_test_condition_wait();
}
void do_test_condition_wait_until() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_until() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_until).join();
do_test_condition_wait_until();
}
void do_test_condition_wait_until_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_until_pred() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_until_pred).join();
do_test_condition_wait_until_pred();
}
void do_test_condition_wait_for() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_for() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_for).join();
do_test_condition_wait_for();
}
void do_test_condition_wait_for_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_for_pred() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_for_pred).join();
do_test_condition_wait_for_pred();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: condition_variable_any test suite");
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
test->add( BOOST_TEST_CASE( & test_condition_wait) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until_pred) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for_pred) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_mutex_mt_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <cstdlib>
#include <iostream>
#include <map>
#include <stdexcept>
#include <vector>
#include <boost/chrono.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread/barrier.hpp>
#include <boost/thread/thread.hpp>
#include <boost/fiber/all.hpp>
typedef boost::chrono::nanoseconds ns;
typedef boost::chrono::milliseconds ms;
int value1 = 0;
int value2 = 0;
template< typename Mtx >
void g( boost::barrier & b, Mtx & m) {
b.wait();
m.lock();
value1 = 3;
m.unlock();
}
template< typename Mtx >
void f( boost::barrier & b, Mtx & m) {
b.wait();
m.lock();
value2 = 7;
m.unlock();
}
template< typename Mtx >
void fn1( boost::barrier & b, Mtx & m) {
boost::fibers::fiber( boost::fibers::launch::dispatch, g< Mtx >, std::ref( b), std::ref( m) ).join();
}
template< typename Mtx >
void fn2( boost::barrier & b, Mtx & m) {
boost::fibers::fiber( boost::fibers::launch::dispatch, f< Mtx >, std::ref( b), std::ref( m) ).join();
}
void test_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_recursive_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::recursive_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::recursive_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_timed_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::timed_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::timed_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::timed_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_recursive_timed_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::recursive_timed_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::recursive_timed_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::recursive_timed_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_dummy() {
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: multithreaded mutex test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add( BOOST_TEST_CASE( & test_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_mutex) );
test->add( BOOST_TEST_CASE( & test_timed_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_timed_mutex) );
#else
test->add( BOOST_TEST_CASE( & test_dummy) );
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_fss_post.cpp | // Copyright (C) 2001-2003
// William E. Kempf
// Copyright (C) 2007 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <mutex>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
boost::fibers::mutex check_mutex;
boost::fibers::mutex fss_mutex;
int fss_instances = 0;
int fss_total = 0;
struct fss_value_t {
fss_value_t() {
std::unique_lock<boost::fibers::mutex> lock(fss_mutex);
++fss_instances;
++fss_total;
value = 0;
}
~fss_value_t() {
std::unique_lock<boost::fibers::mutex> lock(fss_mutex);
--fss_instances;
}
int value;
};
boost::fibers::fiber_specific_ptr<fss_value_t> fss_value;
void fss_fiber() {
fss_value.reset(new fss_value_t());
for (int i=0; i<1000; ++i) {
int& n = fss_value->value;
if (n != i) {
std::unique_lock<boost::fibers::mutex> lock(check_mutex);
BOOST_CHECK_EQUAL(n, i);
}
++n;
}
}
void fss() {
fss_instances = 0;
fss_total = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, fss_fiber);
boost::fibers::fiber f2( boost::fibers::launch::post, fss_fiber);
boost::fibers::fiber f3( boost::fibers::launch::post, fss_fiber);
boost::fibers::fiber f4( boost::fibers::launch::post, fss_fiber);
boost::fibers::fiber f5( boost::fibers::launch::post, fss_fiber);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
std::cout
<< "fss_instances = " << fss_instances
<< "; fss_total = " << fss_total
<< "\n";
std::cout.flush();
BOOST_CHECK_EQUAL(fss_instances, 0);
BOOST_CHECK_EQUAL(fss_total, 5);
}
void test_fss() {
boost::fibers::fiber( boost::fibers::launch::post, fss).join();
}
bool fss_cleanup_called=false;
struct Dummy {
};
void fss_custom_cleanup(Dummy* d) {
delete d;
fss_cleanup_called=true;
}
boost::fibers::fiber_specific_ptr<Dummy> fss_with_cleanup(fss_custom_cleanup);
void fss_fiber_with_custom_cleanup() {
fss_with_cleanup.reset(new Dummy);
}
void fss_with_custom_cleanup() {
boost::fibers::fiber f( boost::fibers::launch::post, fss_fiber_with_custom_cleanup);
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(fss_cleanup_called);
}
void test_fss_with_custom_cleanup() {
boost::fibers::fiber( boost::fibers::launch::post, fss_with_custom_cleanup).join();
}
Dummy* fss_object=new Dummy;
void fss_fiber_with_custom_cleanup_and_release() {
fss_with_cleanup.reset(fss_object);
fss_with_cleanup.release();
}
void do_test_fss_does_no_cleanup_after_release() {
fss_cleanup_called=false;
boost::fibers::fiber f( boost::fibers::launch::post, fss_fiber_with_custom_cleanup_and_release);
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(!fss_cleanup_called);
if(!fss_cleanup_called) {
delete fss_object;
}
}
struct dummy_class_tracks_deletions {
static unsigned deletions;
~dummy_class_tracks_deletions() {
++deletions;
}
};
unsigned dummy_class_tracks_deletions::deletions=0;
boost::fibers::fiber_specific_ptr<dummy_class_tracks_deletions> fss_with_null_cleanup(NULL);
void fss_fiber_with_null_cleanup(dummy_class_tracks_deletions* delete_tracker) {
fss_with_null_cleanup.reset(delete_tracker);
}
void do_test_fss_does_no_cleanup_with_null_cleanup_function() {
dummy_class_tracks_deletions* delete_tracker=new dummy_class_tracks_deletions;
boost::fibers::fiber f( boost::fibers::launch::post, [&delete_tracker](){
fss_fiber_with_null_cleanup( delete_tracker); });
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(!dummy_class_tracks_deletions::deletions);
if(!dummy_class_tracks_deletions::deletions) {
delete delete_tracker;
}
}
void test_fss_does_no_cleanup_after_release() {
boost::fibers::fiber( boost::fibers::launch::post, do_test_fss_does_no_cleanup_after_release).join();
}
void test_fss_does_no_cleanup_with_null_cleanup_function() {
boost::fibers::fiber( boost::fibers::launch::post, do_test_fss_does_no_cleanup_with_null_cleanup_function).join();
}
void fiber_with_local_fss_ptr() {
{
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
}
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
}
void fss_does_not_call_cleanup_after_ptr_destroyed() {
boost::fibers::fiber( boost::fibers::launch::post, fiber_with_local_fss_ptr).join();
BOOST_CHECK(!fss_cleanup_called);
}
void test_fss_does_not_call_cleanup_after_ptr_destroyed() {
boost::fibers::fiber( boost::fibers::launch::post, fss_does_not_call_cleanup_after_ptr_destroyed).join();
}
void fss_cleanup_not_called_for_null_pointer() {
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
fss_cleanup_called=false;
local_fss.reset(0);
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
local_fss.reset(new Dummy);
BOOST_CHECK(!fss_cleanup_called);
}
void test_fss_cleanup_not_called_for_null_pointer() {
boost::fibers::fiber( boost::fibers::launch::post, fss_cleanup_not_called_for_null_pointer).join();
}
void fss_at_the_same_adress() {
for(int i=0; i<2; i++) {
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
fss_cleanup_called=false;
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
BOOST_CHECK(!fss_cleanup_called);
}
}
void test_fss_at_the_same_adress() {
boost::fibers::fiber( boost::fibers::launch::post, fss_at_the_same_adress).join();
}
boost::unit_test::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: fss test suite");
test->add(BOOST_TEST_CASE(test_fss));
test->add(BOOST_TEST_CASE(test_fss_with_custom_cleanup));
test->add(BOOST_TEST_CASE(test_fss_does_no_cleanup_after_release));
test->add(BOOST_TEST_CASE(test_fss_does_no_cleanup_with_null_cleanup_function));
test->add(BOOST_TEST_CASE(test_fss_does_not_call_cleanup_after_ptr_destroyed));
test->add(BOOST_TEST_CASE(test_fss_cleanup_not_called_for_null_pointer));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_future_mt_post.cpp | // (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <boost/fiber/all.hpp>
#include <boost/test/unit_test.hpp>
int fn( int i) {
return i;
}
void test_async() {
for ( int i = 0; i < 10; ++i) {
int n = 3;
boost::fibers::packaged_task< int( int) > pt( fn);
boost::fibers::future< int > f( pt.get_future() );
std::thread t(
std::bind(
[n](boost::fibers::packaged_task< int( int) > & pt) mutable -> void {
boost::fibers::fiber( boost::fibers::launch::post, std::move( pt), n).join();
},
std::move( pt) ) );
int result = f.get();
BOOST_CHECK_EQUAL( n, result);
t.join();
}
}
void test_dummy() {}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: futures-mt test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add(BOOST_TEST_CASE(test_async));
#else
test->add(BOOST_TEST_CASE(test_dummy));
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_shared_future_post.cpp | // (C) Copyright 2008-10 Anthony Williams
// 2015 Oliver Kowalke
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::milliseconds ms;
typedef std::chrono::high_resolution_clock Clock;
int gi = 7;
struct my_exception : public std::runtime_error {
my_exception() :
std::runtime_error("my_exception") {
}
};
struct A {
A() = default;
A( A const&) = delete;
A( A &&) = default;
A & operator=( A const&) = delete;
A & operator=( A &&) = default;
int value;
};
void fn1( boost::fibers::promise< int > * p, int i) {
boost::this_fiber::yield();
p->set_value( i);
}
void fn2() {
boost::fibers::promise< int > p;
boost::fibers::shared_future< int > f( p.get_future().share() );
boost::this_fiber::yield();
boost::fibers::fiber( boost::fibers::launch::post, fn1, & p, 7).detach();
boost::this_fiber::yield();
BOOST_CHECK( 7 == f.get() );
}
int fn3() {
return 3;
}
void fn4() {
}
int fn5() {
boost::throw_exception( my_exception() );
return 3;
}
void fn6() {
boost::throw_exception( my_exception() );
}
int & fn7() {
return gi;
}
int fn8( int i) {
return i;
}
A fn9() {
A a;
a.value = 3;
return a;
}
A fn10() {
boost::throw_exception( my_exception() );
return A();
}
void fn11( boost::fibers::promise< int > p) {
boost::this_fiber::sleep_for( ms(500) );
p.set_value(3);
}
void fn12( boost::fibers::promise< int& > p) {
boost::this_fiber::sleep_for( ms(500) );
gi = 5;
p.set_value( gi);
}
void fn13( boost::fibers::promise< void > p) {
boost::this_fiber::sleep_for( ms(500) );
p.set_value();
}
// shared_future
void test_shared_future_create() {
{
// default constructed and assigned shared_future is not valid
boost::fibers::shared_future< int > f1;
boost::fibers::shared_future< int > f2 = f1;
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
{
// shared_future retrieved from promise is valid
boost::fibers::promise< int > p;
boost::fibers::shared_future< int > f1 = p.get_future();
boost::fibers::shared_future< int > f2 = f1;
BOOST_CHECK( f1.valid() );
BOOST_CHECK( f2.valid() );
}
}
void test_shared_future_create_ref() {
{
// default constructed and assigned shared_future is not valid
boost::fibers::shared_future< int& > f1;
boost::fibers::shared_future< int& > f2 = f1;
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
{
// shared_future retrieved from promise is valid
boost::fibers::promise< int& > p;
boost::fibers::shared_future< int& > f1 = p.get_future();
boost::fibers::shared_future< int& > f2 = f1;
BOOST_CHECK( f1.valid() );
BOOST_CHECK( f2.valid() );
}
}
void test_shared_future_create_void() {
{
// default constructed and assigned shared_future is not valid
boost::fibers::shared_future< void > f1;
boost::fibers::shared_future< void > f2 = f1;
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
{
// shared_future retrieved from promise is valid
boost::fibers::promise< void > p;
boost::fibers::shared_future< void > f1 = p.get_future();
boost::fibers::shared_future< void > f2 = f1;
BOOST_CHECK( f1.valid() );
BOOST_CHECK( f2.valid() );
}
}
void test_shared_future_get() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
p1.set_value( 7);
boost::fibers::shared_future< int > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
BOOST_CHECK( 7 == f1.get() );
BOOST_CHECK( f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< int > p2;
f1 = p2.get_future().share();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( f1.valid() );
BOOST_CHECK( thrown);
}
void test_shared_future_get_move() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< A > p1;
A a; a.value = 7;
p1.set_value( std::move( a) );
boost::fibers::shared_future< A > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
BOOST_CHECK( 7 == f1.get().value);
BOOST_CHECK( f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< A > p2;
f1 = p2.get_future().share();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( f1.valid() );
BOOST_CHECK( thrown);
}
void test_shared_future_get_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
int i = 7;
p1.set_value( i);
boost::fibers::shared_future< int& > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
int & j = f1.get();
BOOST_CHECK( &i == &j);
BOOST_CHECK( f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< int& > p2;
f1 = p2.get_future().share();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( f1.valid() );
BOOST_CHECK( thrown);
}
void test_shared_future_get_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
p1.set_value();
boost::fibers::shared_future< void > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
f1.get();
BOOST_CHECK( f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< void > p2;
f1 = p2.get_future().share();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( f1.valid() );
BOOST_CHECK( thrown);
}
void test_future_share() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
int i = 7;
p1.set_value( i);
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< int > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
int j = sf1.get();
BOOST_CHECK_EQUAL( i, j);
BOOST_CHECK( sf1.valid() );
}
void test_future_share_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
int i = 7;
p1.set_value( i);
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< int& > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
int & j = sf1.get();
BOOST_CHECK( &i == &j);
BOOST_CHECK( sf1.valid() );
}
void test_future_share_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
p1.set_value();
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< void > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
sf1.get();
BOOST_CHECK( sf1.valid() );
}
void test_shared_future_wait() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::shared_future< int > f1 = p1.get_future().share();
// wait on future
p1.set_value( 7);
f1.wait();
BOOST_CHECK( 7 == f1.get() );
}
void test_shared_future_wait_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::shared_future< int& > f1 = p1.get_future().share();
// wait on future
int i = 7;
p1.set_value( i);
f1.wait();
int & j = f1.get();
BOOST_CHECK( &i == &j);
}
void test_shared_future_wait_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::shared_future< void > f1 = p1.get_future().share();
// wait on future
p1.set_value();
f1.wait();
f1.get();
BOOST_CHECK( f1.valid() );
}
void test_shared_future_wait_for() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::shared_future< int > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn11, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_for_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::shared_future< int& > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn12, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_for_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::shared_future< void > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn13, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_until() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::shared_future< int > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn11, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_until_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::shared_future< int& > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn12, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_until_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::shared_future< void > f1 = p1.get_future().share();
boost::fibers::fiber( boost::fibers::launch::post, fn13, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_shared_future_wait_with_fiber_1() {
boost::fibers::promise< int > p1;
boost::fibers::fiber( boost::fibers::launch::post, fn1, & p1, 7).detach();
boost::fibers::shared_future< int > f1 = p1.get_future().share();
// wait on future
BOOST_CHECK( 7 == f1.get() );
}
void test_shared_future_wait_with_fiber_2() {
boost::fibers::fiber( boost::fibers::launch::post, fn2).join();
}
void test_shared_future_move() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::shared_future< int > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::shared_future< int > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_shared_future_move_move() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< A > p1;
boost::fibers::shared_future< A > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::shared_future< A > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_shared_future_move_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::shared_future< int& > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::shared_future< int& > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_shared_future_move_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::shared_future< void > f1 = p1.get_future().share();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::shared_future< void > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: shared_future test suite");
test->add(BOOST_TEST_CASE(test_shared_future_create));
test->add(BOOST_TEST_CASE(test_shared_future_create_ref));
test->add(BOOST_TEST_CASE(test_shared_future_create_void));
test->add(BOOST_TEST_CASE(test_shared_future_move));
test->add(BOOST_TEST_CASE(test_shared_future_move_move));
test->add(BOOST_TEST_CASE(test_shared_future_move_ref));
test->add(BOOST_TEST_CASE(test_shared_future_move_void));
test->add(BOOST_TEST_CASE(test_shared_future_get));
test->add(BOOST_TEST_CASE(test_shared_future_get_move));
test->add(BOOST_TEST_CASE(test_shared_future_get_ref));
test->add(BOOST_TEST_CASE(test_shared_future_get_void));
test->add(BOOST_TEST_CASE(test_shared_future_wait));
test->add(BOOST_TEST_CASE(test_shared_future_wait_ref));
test->add(BOOST_TEST_CASE(test_shared_future_wait_void));
test->add(BOOST_TEST_CASE(test_shared_future_wait_for));
test->add(BOOST_TEST_CASE(test_shared_future_wait_for_ref));
test->add(BOOST_TEST_CASE(test_shared_future_wait_for_void));
test->add(BOOST_TEST_CASE(test_shared_future_wait_until));
test->add(BOOST_TEST_CASE(test_shared_future_wait_until_ref));
test->add(BOOST_TEST_CASE(test_shared_future_wait_until_void));
test->add(BOOST_TEST_CASE(test_shared_future_wait_with_fiber_1));
test->add(BOOST_TEST_CASE(test_shared_future_wait_with_fiber_2));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_buffered_channel_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <sstream>
#include <string>
#include <vector>
#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
struct moveable {
bool state;
int value;
moveable() :
state( false),
value( -1) {
}
moveable( int v) :
state( true),
value( v) {
}
moveable( moveable && other) :
state( other.state),
value( other.value) {
other.state = false;
other.value = -1;
}
moveable & operator=( moveable && other) {
if ( this == & other) return * this;
state = other.state;
other.state = false;
value = other.value;
other.value = -1;
return * this;
}
};
void test_zero_wm() {
bool thrown = false;
try {
boost::fibers::buffered_channel< int > c( 0);
} catch ( boost::fibers::fiber_error const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_push() {
boost::fibers::buffered_channel< int > c( 16);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
}
void test_push_closed() {
boost::fibers::buffered_channel< int > c( 16);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push( 1) );
}
void test_try_push() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
}
void test_try_push_closed() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_push( 1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.try_push( 2) );
}
void test_try_push_full() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_push( 1) );
BOOST_CHECK( boost::fibers::channel_op_status::full == c.try_push( 1) );
}
void test_push_wait_for() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_for_closed() {
boost::fibers::buffered_channel< int > c( 2);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_for_timeout() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_until() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_push_wait_until_closed() {
boost::fibers::buffered_channel< int > c( 2);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_push_wait_until_timeout() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop( v2) );
}
void test_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
v2 = c.value_pop();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
v2 = c.value_pop();
BOOST_CHECK_EQUAL( v1, v2);
bool thrown = false;
try {
c.value_pop();
} catch ( boost::fibers::fiber_error const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_value_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&v2](){
v2 = c.value_pop();
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_try_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_try_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.try_pop( v2) );
}
void test_try_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&v2](){
while ( boost::fibers::channel_op_status::success != c.try_pop( v2) ) {
boost::this_fiber::yield();
}
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
}
void test_pop_wait_for_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_timeout() {
boost::fibers::buffered_channel< int > c( 16);
int v = 0;
boost::fibers::fiber f( boost::fibers::launch::dispatch, [&c,&v](){
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.pop_wait_for( v, std::chrono::seconds( 1) ) );
});
f.join();
}
void test_pop_wait_until() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_until_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_pop_wait_until_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_until_timeout() {
boost::fibers::buffered_channel< int > c( 16);
int v = 0;
boost::fibers::fiber f( boost::fibers::launch::dispatch, [&c,&v](){
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.pop_wait_until( v,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
f.join();
}
void test_wm_1() {
boost::fibers::buffered_channel< int > c( 4);
std::vector< boost::fibers::fiber::id > ids;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 2) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 3) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 4) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 5) );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 1, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 2, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 3, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 4, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
// would block because channel is empty
BOOST_CHECK_EQUAL( 5, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber::id id1 = f1.get_id();
boost::fibers::fiber::id id2 = f2.get_id();
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 12u, ids.size() );
BOOST_CHECK_EQUAL( id1, ids[0]);
BOOST_CHECK_EQUAL( id1, ids[1]);
BOOST_CHECK_EQUAL( id1, ids[2]);
BOOST_CHECK_EQUAL( id1, ids[3]);
BOOST_CHECK_EQUAL( id2, ids[4]);
BOOST_CHECK_EQUAL( id1, ids[5]);
BOOST_CHECK_EQUAL( id2, ids[6]);
BOOST_CHECK_EQUAL( id2, ids[7]);
BOOST_CHECK_EQUAL( id2, ids[8]);
BOOST_CHECK_EQUAL( id2, ids[9]);
BOOST_CHECK_EQUAL( id1, ids[10]);
BOOST_CHECK_EQUAL( id2, ids[11]);
}
void test_wm_2() {
boost::fibers::buffered_channel< int > c( 4);
std::vector< boost::fibers::fiber::id > ids;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 2) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 3) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 4) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 5) );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 1, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 2, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 3, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 4, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 5, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber::id id1 = f1.get_id();
boost::fibers::fiber::id id2 = f2.get_id();
f1.join();
f2.join();
BOOST_CHECK_EQUAL( (std::size_t)12, ids.size() );
BOOST_CHECK_EQUAL( id1, ids[0]);
BOOST_CHECK_EQUAL( id1, ids[1]);
BOOST_CHECK_EQUAL( id1, ids[2]);
BOOST_CHECK_EQUAL( id1, ids[3]);
BOOST_CHECK_EQUAL( id2, ids[4]);
BOOST_CHECK_EQUAL( id1, ids[5]);
BOOST_CHECK_EQUAL( id2, ids[6]);
BOOST_CHECK_EQUAL( id1, ids[7]);
BOOST_CHECK_EQUAL( id2, ids[8]);
BOOST_CHECK_EQUAL( id2, ids[9]);
BOOST_CHECK_EQUAL( id2, ids[10]);
BOOST_CHECK_EQUAL( id2, ids[11]);
}
void test_moveable() {
boost::fibers::buffered_channel< moveable > c( 16);
moveable m1( 3), m2;
BOOST_CHECK( m1.state);
BOOST_CHECK_EQUAL( 3, m1.value);
BOOST_CHECK( ! m2.state);
BOOST_CHECK_EQUAL( -1, m2.value);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( std::move( m1) ) );
BOOST_CHECK( ! m1.state);
BOOST_CHECK( ! m2.state);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( m2) );
BOOST_CHECK( ! m1.state);
BOOST_CHECK_EQUAL( -1, m1.value);
BOOST_CHECK( m2.state);
BOOST_CHECK_EQUAL( 3, m2.value);
}
void test_rangefor() {
boost::fibers::buffered_channel< int > chan{ 4 };
std::vector< int > vec;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, [&chan]{
chan.push( 1);
chan.push( 1);
chan.push( 2);
chan.push( 3);
chan.push( 5);
chan.push( 8);
chan.push( 12);
chan.close();
});
boost::fibers::fiber f2( boost::fibers::launch::dispatch, [&vec,&chan]{
for ( int value : chan) {
vec.push_back( value);
}
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, vec[0]);
BOOST_CHECK_EQUAL( 1, vec[1]);
BOOST_CHECK_EQUAL( 2, vec[2]);
BOOST_CHECK_EQUAL( 3, vec[3]);
BOOST_CHECK_EQUAL( 5, vec[4]);
BOOST_CHECK_EQUAL( 8, vec[5]);
BOOST_CHECK_EQUAL( 12, vec[6]);
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: buffered_channel test suite");
test->add( BOOST_TEST_CASE( & test_zero_wm) );
test->add( BOOST_TEST_CASE( & test_push) );
test->add( BOOST_TEST_CASE( & test_push_closed) );
test->add( BOOST_TEST_CASE( & test_try_push) );
test->add( BOOST_TEST_CASE( & test_try_push_closed) );
test->add( BOOST_TEST_CASE( & test_try_push_full) );
test->add( BOOST_TEST_CASE( & test_push_wait_for) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_push_wait_until) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_pop) );
test->add( BOOST_TEST_CASE( & test_pop_closed) );
test->add( BOOST_TEST_CASE( & test_pop_success) );
test->add( BOOST_TEST_CASE( & test_value_pop) );
test->add( BOOST_TEST_CASE( & test_value_pop_closed) );
test->add( BOOST_TEST_CASE( & test_value_pop_success) );
test->add( BOOST_TEST_CASE( & test_try_pop) );
test->add( BOOST_TEST_CASE( & test_try_pop_closed) );
test->add( BOOST_TEST_CASE( & test_try_pop_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_wm_1) );
test->add( BOOST_TEST_CASE( & test_wm_2) );
test->add( BOOST_TEST_CASE( & test_moveable) );
test->add( BOOST_TEST_CASE( & test_rangefor) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_variable_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
inline
std::chrono::system_clock::time_point delay(int secs, int msecs = 0, int /*nsecs*/ = 0) {
std::chrono::system_clock::time_point t = std::chrono::system_clock::now();
t += std::chrono::seconds( secs);
t += std::chrono::milliseconds( msecs);
//t += std::chrono::nanoseconds( nsecs);
return t;
}
struct condition_test_data {
condition_test_data() : notified(0), awoken(0) { }
boost::fibers::mutex mutex;
boost::fibers::condition_variable cond;
int notified;
int awoken;
};
void condition_test_fiber(condition_test_data* data) {
std::unique_lock<boost::fibers::mutex> lock(data->mutex);
BOOST_CHECK(lock ? true : false);
while (!(data->notified > 0))
data->cond.wait(lock);
BOOST_CHECK(lock ? true : false);
data->awoken++;
}
struct cond_predicate {
cond_predicate(int& var, int val) : _var(var), _val(val) { }
bool operator()() { return _var == _val; }
int& _var;
int _val;
private:
void operator=(cond_predicate&);
};
void notify_one_fn( boost::fibers::condition_variable & cond) {
cond.notify_one();
}
void notify_all_fn( boost::fibers::condition_variable & cond) {
cond.notify_all();
}
void wait_fn(
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond) {
std::unique_lock< boost::fibers::mutex > lk( mtx);
cond.wait( lk);
++value1;
}
void test_one_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
}
void test_two_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 1, value1);
f1.join();
f2.join();
f3.join();
f4.join();
BOOST_CHECK_EQUAL( 2, value1);
}
void test_two_waiter_notify_all() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::dispatch,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 2, value1);
boost::fibers::fiber f5(
boost::fibers::launch::dispatch,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 2, value1);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
BOOST_CHECK_EQUAL( 3, value1);
}
int test1 = 0;
int test2 = 0;
int runs = 0;
void fn1( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0) {
cv.wait(lk);
}
BOOST_CHECK(test2 != 0);
}
void fn2( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::system_clock::time_point t0 = std::chrono::system_clock::now();
std::chrono::system_clock::time_point t = t0 + ms(250);
int count=0;
while (test2 == 0 && cv.wait_until(lk, t) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
}
class Pred {
int & i_;
public:
explicit Pred(int& i) :
i_(i)
{}
bool operator()()
{ return i_ != 0; }
};
void fn3( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point t = t0 + ms(250);
bool r = cv.wait_until(lk, t, Pred(test2));
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
BOOST_CHECK(r);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(250+100));
BOOST_CHECK(test2 == 0);
BOOST_CHECK(!r);
}
++runs;
}
void fn4( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
while (test2 == 0 && cv.wait_for(lk, ms(250)) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
}
void fn5( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
cv.wait_for(lk, ms(250), Pred(test2));
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250+1000));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100));
BOOST_CHECK(test2 == 0);
}
++runs;
}
void do_test_condition_wait() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn1, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
void test_condition_wait() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait).join();
do_test_condition_wait();
}
void do_test_condition_wait_until() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_until() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_until).join();
do_test_condition_wait_until();
}
void do_test_condition_wait_until_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_until_pred() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_until_pred).join();
do_test_condition_wait_until_pred();
}
void do_test_condition_wait_for() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_for() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_for).join();
do_test_condition_wait_for();
}
void do_test_condition_wait_for_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_for_pred() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_condition_wait_for_pred).join();
do_test_condition_wait_for_pred();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
{
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: condition_variable test suite");
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
test->add( BOOST_TEST_CASE( & test_condition_wait) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until_pred) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for_pred) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_barrier_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <sstream>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int value1 = 0;
int value2 = 0;
void fn1( boost::fibers::barrier & b) {
++value1;
boost::this_fiber::yield();
b.wait();
++value1;
boost::this_fiber::yield();
++value1;
boost::this_fiber::yield();
++value1;
boost::this_fiber::yield();
++value1;
}
void fn2( boost::fibers::barrier & b) {
++value2;
boost::this_fiber::yield();
++value2;
boost::this_fiber::yield();
++value2;
boost::this_fiber::yield();
b.wait();
++value2;
boost::this_fiber::yield();
++value2;
}
void test_barrier() {
value1 = 0;
value2 = 0;
boost::fibers::barrier b( 2);
boost::fibers::fiber f1( boost::fibers::launch::post, fn1, std::ref( b) );
boost::fibers::fiber f2( boost::fibers::launch::post, fn2, std::ref( b) );
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 5, value1);
BOOST_CHECK_EQUAL( 5, value2);
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: barrier test suite");
test->add( BOOST_TEST_CASE( & test_barrier) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_mutex_mt_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <cstdlib>
#include <iostream>
#include <map>
#include <stdexcept>
#include <vector>
#include <boost/chrono.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread/barrier.hpp>
#include <boost/thread/thread.hpp>
#include <boost/fiber/all.hpp>
typedef boost::chrono::nanoseconds ns;
typedef boost::chrono::milliseconds ms;
int value1 = 0;
int value2 = 0;
template< typename Mtx >
void g( boost::barrier & b, Mtx & m) {
b.wait();
m.lock();
value1 = 3;
m.unlock();
}
template< typename Mtx >
void f( boost::barrier & b, Mtx & m) {
b.wait();
m.lock();
value2 = 7;
m.unlock();
}
template< typename Mtx >
void fn1( boost::barrier & b, Mtx & m) {
boost::fibers::fiber( boost::fibers::launch::post, g< Mtx >, std::ref( b), std::ref( m) ).join();
}
template< typename Mtx >
void fn2( boost::barrier & b, Mtx & m) {
boost::fibers::fiber( boost::fibers::launch::post, f< Mtx >, std::ref( b), std::ref( m) ).join();
}
void test_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_recursive_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::recursive_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::recursive_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_timed_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::timed_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::timed_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::timed_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_recursive_timed_mutex() {
for ( int i = 0; i < 10; ++i) {
boost::fibers::recursive_timed_mutex mtx;
mtx.lock();
boost::barrier b( 3);
boost::thread t1( fn1< boost::fibers::recursive_timed_mutex >, std::ref( b), std::ref( mtx) );
boost::thread t2( fn2< boost::fibers::recursive_timed_mutex >, std::ref( b), std::ref( mtx) );
b.wait();
boost::this_thread::sleep_for( ms( 250) );
mtx.unlock();
t1.join();
t2.join();
BOOST_CHECK( 3 == value1);
BOOST_CHECK( 7 == value2);
}
}
void test_dummy() {
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: multithreaded mutex test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add( BOOST_TEST_CASE( & test_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_mutex) );
test->add( BOOST_TEST_CASE( & test_timed_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_timed_mutex) );
#else
test->add( BOOST_TEST_CASE( & test_dummy) );
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_variable_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
inline
std::chrono::system_clock::time_point delay(int secs, int msecs = 0, int /*nsecs*/ = 0) {
std::chrono::system_clock::time_point t = std::chrono::system_clock::now();
t += std::chrono::seconds( secs);
t += std::chrono::milliseconds( msecs);
//t += std::chrono::nanoseconds( nsecs);
return t;
}
struct condition_test_data {
condition_test_data() : notified(0), awoken(0) { }
boost::fibers::mutex mutex;
boost::fibers::condition_variable cond;
int notified;
int awoken;
};
void condition_test_fiber(condition_test_data* data) {
std::unique_lock<boost::fibers::mutex> lock(data->mutex);
BOOST_CHECK(lock ? true : false);
while (!(data->notified > 0))
data->cond.wait(lock);
BOOST_CHECK(lock ? true : false);
data->awoken++;
}
struct cond_predicate {
cond_predicate(int& var, int val) : _var(var), _val(val) { }
bool operator()() { return _var == _val; }
int& _var;
int _val;
private:
void operator=(cond_predicate&);
};
void notify_one_fn( boost::fibers::condition_variable & cond) {
cond.notify_one();
}
void notify_all_fn( boost::fibers::condition_variable & cond) {
cond.notify_all();
}
void wait_fn(
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond) {
std::unique_lock< boost::fibers::mutex > lk( mtx);
cond.wait( lk);
++value1;
}
void test_one_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
}
void test_two_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
f3.join();
f4.join();
BOOST_CHECK_EQUAL( 2, value1);
}
void test_two_waiter_notify_all() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::post,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f5(
boost::fibers::launch::post,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
BOOST_CHECK_EQUAL( 3, value1);
}
int test1 = 0;
int test2 = 0;
int runs = 0;
void fn1( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0) {
cv.wait(lk);
}
BOOST_CHECK(test2 != 0);
}
void fn2( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::system_clock::time_point t0 = std::chrono::system_clock::now();
std::chrono::system_clock::time_point t = t0 + ms(250);
int count=0;
while (test2 == 0 && cv.wait_until(lk, t) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
}
class Pred {
int & i_;
public:
explicit Pred(int& i) :
i_(i)
{}
bool operator()()
{ return i_ != 0; }
};
void fn3( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point t = t0 + ms(250);
bool r = cv.wait_until(lk, t, Pred(test2));
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
BOOST_CHECK(r);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(250+100));
BOOST_CHECK(test2 == 0);
BOOST_CHECK(!r);
}
++runs;
}
void fn4( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
while (test2 == 0 && cv.wait_for(lk, ms(250)) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
}
void fn5( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) {
std::unique_lock< boost::fibers::mutex > lk( m);
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
cv.wait_for(lk, ms(250), Pred(test2));
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250+1000));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100));
BOOST_CHECK(test2 == 0);
}
++runs;
}
void do_test_condition_wait() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn1, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
void test_condition_wait() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait).join();
do_test_condition_wait();
}
void do_test_condition_wait_until() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_until() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_until).join();
do_test_condition_wait_until();
}
void do_test_condition_wait_until_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_until_pred() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_until_pred).join();
do_test_condition_wait_until_pred();
}
void do_test_condition_wait_for() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_for() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_for).join();
do_test_condition_wait_for();
}
void do_test_condition_wait_for_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable cv;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
test2 = 1;
lk.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
std::unique_lock< boost::fibers::mutex > lk( m);
boost::fibers::fiber f( boost::fibers::launch::post, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(lk);
BOOST_CHECK(test1 != 0);
lk.unlock();
f.join();
}
}
void test_condition_wait_for_pred() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_for_pred).join();
do_test_condition_wait_for_pred();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
{
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: condition_variable test suite");
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
test->add( BOOST_TEST_CASE( & test_condition_wait) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until_pred) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for_pred) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_buffered_channel_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <sstream>
#include <string>
#include <vector>
#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
struct moveable {
bool state;
int value;
moveable() :
state( false),
value( -1) {
}
moveable( int v) :
state( true),
value( v) {
}
moveable( moveable && other) :
state( other.state),
value( other.value) {
other.state = false;
other.value = -1;
}
moveable & operator=( moveable && other) {
if ( this == & other) return * this;
state = other.state;
other.state = false;
value = other.value;
other.value = -1;
return * this;
}
};
void test_zero_wm() {
bool thrown = false;
try {
boost::fibers::buffered_channel< int > c( 0);
} catch ( boost::fibers::fiber_error const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_push() {
boost::fibers::buffered_channel< int > c( 16);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
}
void test_push_closed() {
boost::fibers::buffered_channel< int > c( 16);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push( 1) );
}
void test_try_push() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
}
void test_try_push_closed() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_push( 1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.try_push( 2) );
}
void test_try_push_full() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_push( 1) );
BOOST_CHECK( boost::fibers::channel_op_status::full == c.try_push( 2) );
}
void test_push_wait_for() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_for_closed() {
boost::fibers::buffered_channel< int > c( 2);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_for_timeout() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_for( 2, std::chrono::seconds( 1) ) );
}
void test_push_wait_until() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_push_wait_until_closed() {
boost::fibers::buffered_channel< int > c( 2);
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_push_wait_until_timeout() {
boost::fibers::buffered_channel< int > c( 2);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_until( 2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop( v2) );
}
void test_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
v2 = c.value_pop();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
v2 = c.value_pop();
BOOST_CHECK_EQUAL( v1, v2);
bool thrown = false;
try {
c.value_pop();
} catch ( boost::fibers::fiber_error const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_value_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&v2](){
v2 = c.value_pop();
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_try_pop() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_try_pop_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.try_pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.try_pop( v2) );
}
void test_try_pop_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&v2](){
while ( boost::fibers::channel_op_status::success != c.try_pop( v2) ) {
boost::this_fiber::yield();
}
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
}
void test_pop_wait_for_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_timeout() {
boost::fibers::buffered_channel< int > c( 16);
int v = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v](){
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.pop_wait_for( v, std::chrono::seconds( 1) ) );
});
f.join();
}
void test_pop_wait_until() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_until_closed() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_pop_wait_until_success() {
boost::fibers::buffered_channel< int > c( 16);
int v1 = 2, v2 = 0;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_until_timeout() {
boost::fibers::buffered_channel< int > c( 16);
int v = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v](){
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.pop_wait_until( v,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
f.join();
}
void test_wm_1() {
boost::fibers::buffered_channel< int > c( 4);
std::vector< boost::fibers::fiber::id > ids;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 2) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 3) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 4) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 5) );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 1, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 2, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 3, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 4, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
// would block because channel is empty
BOOST_CHECK_EQUAL( 5, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber::id id1 = f1.get_id();
boost::fibers::fiber::id id2 = f2.get_id();
f1.join();
f2.join();
BOOST_CHECK_EQUAL( (std::size_t)12, ids.size() );
BOOST_CHECK_EQUAL( id1, ids[0]);
BOOST_CHECK_EQUAL( id1, ids[1]);
BOOST_CHECK_EQUAL( id1, ids[2]);
BOOST_CHECK_EQUAL( id1, ids[3]);
BOOST_CHECK_EQUAL( id2, ids[4]);
BOOST_CHECK_EQUAL( id1, ids[5]);
BOOST_CHECK_EQUAL( id2, ids[6]);
BOOST_CHECK_EQUAL( id2, ids[7]);
BOOST_CHECK_EQUAL( id2, ids[8]);
BOOST_CHECK_EQUAL( id2, ids[9]);
BOOST_CHECK_EQUAL( id1, ids[10]);
BOOST_CHECK_EQUAL( id2, ids[11]);
}
void test_wm_2() {
boost::fibers::buffered_channel< int > c( 8);
std::vector< boost::fibers::fiber::id > ids;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 2) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 3) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 4) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 5) );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 1, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 2, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 3, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 4, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 5, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber::id id1 = f1.get_id();
boost::fibers::fiber::id id2 = f2.get_id();
f1.join();
f2.join();
BOOST_CHECK_EQUAL( (std::size_t)12, ids.size() );
BOOST_CHECK_EQUAL( id1, ids[0]);
BOOST_CHECK_EQUAL( id1, ids[1]);
BOOST_CHECK_EQUAL( id1, ids[2]);
BOOST_CHECK_EQUAL( id1, ids[3]);
BOOST_CHECK_EQUAL( id1, ids[4]);
BOOST_CHECK_EQUAL( id1, ids[5]);
BOOST_CHECK_EQUAL( id2, ids[6]);
BOOST_CHECK_EQUAL( id2, ids[7]);
BOOST_CHECK_EQUAL( id2, ids[8]);
BOOST_CHECK_EQUAL( id2, ids[9]);
BOOST_CHECK_EQUAL( id2, ids[10]);
BOOST_CHECK_EQUAL( id2, ids[11]);
}
void test_moveable() {
boost::fibers::buffered_channel< moveable > c( 16);
moveable m1( 3), m2;
BOOST_CHECK( m1.state);
BOOST_CHECK_EQUAL( 3, m1.value);
BOOST_CHECK( ! m2.state);
BOOST_CHECK_EQUAL( -1, m2.value);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( std::move( m1) ) );
BOOST_CHECK( ! m1.state);
BOOST_CHECK( ! m2.state);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( m2) );
BOOST_CHECK( ! m1.state);
BOOST_CHECK_EQUAL( -1, m1.value);
BOOST_CHECK( m2.state);
BOOST_CHECK_EQUAL( 3, m2.value);
}
void test_rangefor() {
boost::fibers::buffered_channel< int > chan{ 2 };
std::vector< int > vec;
boost::fibers::fiber f1([&chan]{
chan.push( 1);
chan.push( 1);
chan.push( 2);
chan.push( 3);
chan.push( 5);
chan.push( 8);
chan.push( 12);
chan.close();
});
boost::fibers::fiber f2([&vec,&chan]{
for ( int value : chan) {
vec.push_back( value);
}
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, vec[0]);
BOOST_CHECK_EQUAL( 1, vec[1]);
BOOST_CHECK_EQUAL( 2, vec[2]);
BOOST_CHECK_EQUAL( 3, vec[3]);
BOOST_CHECK_EQUAL( 5, vec[4]);
BOOST_CHECK_EQUAL( 8, vec[5]);
BOOST_CHECK_EQUAL( 12, vec[6]);
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: buffered_channel test suite");
test->add( BOOST_TEST_CASE( & test_zero_wm) );
test->add( BOOST_TEST_CASE( & test_push) );
test->add( BOOST_TEST_CASE( & test_push_closed) );
test->add( BOOST_TEST_CASE( & test_try_push) );
test->add( BOOST_TEST_CASE( & test_try_push_closed) );
test->add( BOOST_TEST_CASE( & test_try_push_full) );
test->add( BOOST_TEST_CASE( & test_push_wait_for) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_push_wait_until) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_pop) );
test->add( BOOST_TEST_CASE( & test_pop_closed) );
test->add( BOOST_TEST_CASE( & test_pop_success) );
test->add( BOOST_TEST_CASE( & test_value_pop) );
test->add( BOOST_TEST_CASE( & test_value_pop_closed) );
test->add( BOOST_TEST_CASE( & test_value_pop_success) );
test->add( BOOST_TEST_CASE( & test_try_pop) );
test->add( BOOST_TEST_CASE( & test_try_pop_closed) );
test->add( BOOST_TEST_CASE( & test_try_pop_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_wm_1) );
test->add( BOOST_TEST_CASE( & test_wm_2) );
test->add( BOOST_TEST_CASE( & test_moveable) );
test->add( BOOST_TEST_CASE( & test_rangefor) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_mt_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/atomic.hpp>
#include <boost/bind.hpp>
#include <boost/chrono.hpp>
#include <boost/cstdint.hpp>
#include <boost/function.hpp>
#include <boost/ref.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread.hpp>
#include <boost/utility.hpp>
#include <boost/fiber/all.hpp>
typedef boost::chrono::milliseconds ms;
boost::atomic< int > value1;
void wait_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
cond.wait( lk, [&flag](){ return flag; });
++value1;
}
void notify_one_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
flag = true;
lk.unlock();
cond.notify_one();
}
void notify_all_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
flag = true;
lk.unlock();
cond.notify_all();
}
void fn1( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::post,
wait_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void fn2( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::post,
notify_one_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void fn3( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::post,
notify_all_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void test_one_waiter_notify_one() {
for ( int i = 0; i < 10; ++i) {
boost::barrier b( 2);
bool flag = false;
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
BOOST_CHECK( 0 == value1);
boost::thread t1(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t2(std::bind( fn2, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
t1.join();
t2.join();
BOOST_CHECK( 1 == value1);
}
}
void test_two_waiter_notify_all() {
for ( int i = 0; i < 10; ++i) {
boost::barrier b( 3);
bool flag = false;
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
BOOST_CHECK( 0 == value1);
boost::thread t1(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t2(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t3(std::bind( fn3, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
t1.join();
t2.join();
t3.join();
BOOST_CHECK( 2 == value1);
}
}
void test_dummy() {
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
{
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: multithreaded condition_variable test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
#else
test->add( BOOST_TEST_CASE( & test_dummy) );
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_fiber_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <mutex>
#include <sstream>
#include <string>
#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int value1 = 0;
std::string value2 = "";
struct X {
int value;
void foo( int i) {
value = i;
}
};
class copyable {
public:
bool state;
int value;
copyable() :
state( false),
value( -1) {
}
copyable( int v) :
state( true),
value( v) {
}
void operator()() {
value1 = value;
}
};
class moveable {
public:
bool state;
int value;
moveable() :
state( false),
value( -1) {
}
moveable( int v) :
state( true),
value( v) {
}
moveable( moveable && other) :
state( other.state),
value( other.value) {
other.state = false;
other.value = -1;
}
moveable & operator=( moveable && other) {
if ( this == & other) return * this;
state = other.state;
value = other.value;
other.state = false;
other.value = -1;
return * this;
}
moveable( moveable const& other) = delete;
moveable & operator=( moveable const& other) = delete;
void operator()() {
value1 = value;
}
};
class detachable {
private:
int alive_count_;
public:
static int alive_count;
static bool was_running;
detachable() :
alive_count_( 1) {
++alive_count;
}
detachable( detachable const& g) :
alive_count_( g.alive_count_) {
++alive_count;
}
~detachable() {
alive_count_ = 0;
--alive_count;
}
void operator()() {
BOOST_CHECK_EQUAL(1, alive_count_);
was_running = true;
}
};
int detachable::alive_count = 0;
bool detachable::was_running = false;
void fn1() {
value1 = 1;
}
void fn2( int i, std::string const& s) {
value1 = i;
value2 = s;
}
void fn3( int & i) {
i = 1;
boost::this_fiber::yield();
i = 1;
boost::this_fiber::yield();
i = 2;
boost::this_fiber::yield();
i = 3;
boost::this_fiber::yield();
i = 5;
boost::this_fiber::yield();
i = 8;
}
void fn4() {
boost::this_fiber::yield();
}
void fn5() {
boost::fibers::fiber f( boost::fibers::launch::dispatch, fn4);
BOOST_CHECK( f.joinable() );
f.join();
BOOST_CHECK( ! f.joinable() );
}
void test_scheduler_dtor() {
boost::fibers::context * ctx(
boost::fibers::context::active() );
(void)ctx;
}
void test_join_fn() {
{
value1 = 0;
boost::fibers::fiber f( boost::fibers::launch::dispatch, fn1);
f.join();
BOOST_CHECK_EQUAL( value1, 1);
}
{
value1 = 0;
value2 = "";
boost::fibers::fiber f( boost::fibers::launch::dispatch, fn2, 3, "abc");
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_memfn() {
X x = {0};
BOOST_CHECK_EQUAL( x.value, 0);
boost::fibers::fiber( boost::fibers::launch::dispatch, & X::foo, & x, 3).join();
BOOST_CHECK_EQUAL( x.value, 3);
}
void test_join_copyable() {
value1 = 0;
copyable cp( 3);
BOOST_CHECK( cp.state);
BOOST_CHECK_EQUAL( value1, 0);
boost::fibers::fiber f( boost::fibers::launch::dispatch, cp);
f.join();
BOOST_CHECK( cp.state);
BOOST_CHECK_EQUAL( value1, 3);
}
void test_join_moveable() {
value1 = 0;
moveable mv( 7);
BOOST_CHECK( mv.state);
BOOST_CHECK_EQUAL( value1, 0);
boost::fibers::fiber f( boost::fibers::launch::dispatch, std::move( mv) );
f.join();
BOOST_CHECK( ! mv.state);
BOOST_CHECK_EQUAL( value1, 7);
}
void test_join_lambda() {
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::dispatch, [i,abc]() {
value1 = i;
value2 = abc;
});
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::dispatch, [](int i, std::string const& abc) {
value1 = i;
value2 = abc;
},
i, abc);
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_bind() {
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::dispatch, std::bind(
[i,abc]() {
value1 = i;
value2 = abc;
}
));
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::dispatch, std::bind(
[](std::string & str) {
value1 = 3;
value2 = str;
},
abc
));
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::dispatch, std::bind(
[]( std::string & str) {
value1 = 3;
value2 = str;
},
std::placeholders::_1
),
std::ref( abc) );
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_in_fiber() {
// spawn fiber f
// f spawns an new fiber f' in its fiber-fn
// f' yields in its fiber-fn
// f joins s' and gets suspended (waiting on s')
boost::fibers::fiber f( boost::fibers::launch::dispatch, fn5);
BOOST_CHECK( f.joinable() );
// join() resumes f + f' which completes
f.join();
BOOST_CHECK( ! f.joinable() );
}
void test_move_fiber() {
boost::fibers::fiber f1;
BOOST_CHECK( ! f1.joinable() );
boost::fibers::fiber f2( boost::fibers::launch::dispatch, fn1);
BOOST_CHECK( f2.joinable() );
f1 = std::move( f2);
BOOST_CHECK( f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
f1.join();
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
}
void test_id() {
boost::fibers::fiber f1;
boost::fibers::fiber f2( boost::fibers::launch::dispatch, fn1);
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( f2.joinable() );
BOOST_CHECK_EQUAL( boost::fibers::fiber::id(), f1.get_id() );
BOOST_CHECK( boost::fibers::fiber::id() != f2.get_id() );
boost::fibers::fiber f3( boost::fibers::launch::dispatch, fn1);
BOOST_CHECK( f2.get_id() != f3.get_id() );
f1 = std::move( f2);
BOOST_CHECK( f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
BOOST_CHECK( boost::fibers::fiber::id() != f1.get_id() );
BOOST_CHECK_EQUAL( boost::fibers::fiber::id(), f2.get_id() );
BOOST_CHECK( ! f2.joinable() );
f1.join();
f3.join();
}
void test_yield() {
int v1 = 0, v2 = 0;
BOOST_CHECK_EQUAL( 0, v1);
BOOST_CHECK_EQUAL( 0, v2);
boost::fibers::fiber f1( boost::fibers::launch::dispatch, fn3, std::ref( v1) );
boost::fibers::fiber f2( boost::fibers::launch::dispatch, fn3, std::ref( v2) );
f1.join();
f2.join();
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
BOOST_CHECK_EQUAL( 8, v1);
BOOST_CHECK_EQUAL( 8, v2);
}
void test_sleep_for() {
typedef std::chrono::system_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_for(ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the fiber system switches the fiber
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
void test_sleep_until() {
{
typedef std::chrono::steady_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_until(t0 + ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the thread system switches the threads
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
{
typedef std::chrono::system_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_until(t0 + ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the thread system switches the threads
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
}
void do_wait( boost::fibers::barrier* b) {
b->wait();
}
void test_detach() {
{
boost::fibers::fiber f( boost::fibers::launch::dispatch, (detachable()) );
BOOST_CHECK( f.joinable() );
f.detach();
BOOST_CHECK( ! f.joinable() );
boost::this_fiber::sleep_for( std::chrono::milliseconds(250) );
BOOST_CHECK( detachable::was_running);
BOOST_CHECK_EQUAL( 0, detachable::alive_count);
}
{
boost::fibers::fiber f( boost::fibers::launch::dispatch, (detachable()) );
BOOST_CHECK( f.joinable() );
boost::this_fiber::yield();
f.detach();
BOOST_CHECK( ! f.joinable() );
boost::this_fiber::sleep_for( std::chrono::milliseconds(250) );
BOOST_CHECK( detachable::was_running);
BOOST_CHECK_EQUAL( 0, detachable::alive_count);
}
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: fiber test suite");
test->add( BOOST_TEST_CASE( & test_scheduler_dtor) );
test->add( BOOST_TEST_CASE( & test_join_fn) );
test->add( BOOST_TEST_CASE( & test_join_memfn) );
test->add( BOOST_TEST_CASE( & test_join_copyable) );
test->add( BOOST_TEST_CASE( & test_join_moveable) );
test->add( BOOST_TEST_CASE( & test_join_lambda) );
test->add( BOOST_TEST_CASE( & test_join_bind) );
test->add( BOOST_TEST_CASE( & test_join_in_fiber) );
test->add( BOOST_TEST_CASE( & test_move_fiber) );
test->add( BOOST_TEST_CASE( & test_yield) );
test->add( BOOST_TEST_CASE( & test_sleep_for) );
test->add( BOOST_TEST_CASE( & test_sleep_until) );
test->add( BOOST_TEST_CASE( & test_detach) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_barrier_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <sstream>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int value1 = 0;
int value2 = 0;
void fn1( boost::fibers::barrier & b) {
++value1;
boost::this_fiber::yield();
b.wait();
++value1;
boost::this_fiber::yield();
++value1;
boost::this_fiber::yield();
++value1;
boost::this_fiber::yield();
++value1;
}
void fn2( boost::fibers::barrier & b) {
++value2;
boost::this_fiber::yield();
++value2;
boost::this_fiber::yield();
++value2;
boost::this_fiber::yield();
b.wait();
++value2;
boost::this_fiber::yield();
++value2;
}
void test_barrier() {
value1 = 0;
value2 = 0;
boost::fibers::barrier b( 2);
boost::fibers::fiber f1( boost::fibers::launch::dispatch, fn1, std::ref( b) );
boost::fibers::fiber f2( boost::fibers::launch::dispatch, fn2, std::ref( b) );
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 5, value1);
BOOST_CHECK_EQUAL( 5, value2);
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: barrier test suite");
test->add( BOOST_TEST_CASE( & test_barrier) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_mutex_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
int value2 = 0;
template< typename M >
void fn1( M & mtx) {
typedef M mutex_type;
typename std::unique_lock< mutex_type > lk( mtx);
++value1;
for ( int i = 0; i < 3; ++i)
boost::this_fiber::yield();
}
template< typename M >
void fn2( M & mtx) {
typedef M mutex_type;
++value2;
typename std::unique_lock< mutex_type > lk( mtx);
++value2;
}
void fn3( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(2500000)+ms(2000)); // within 2.5 ms
}
void fn4( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while ( ! m.try_lock() );
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
void fn5( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK( m.try_lock_for(ms(300)+ms(2000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn6( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn7( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(300) + ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5ms
}
void fn8( boost::fibers::timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
ns r = ns(5000000)+ms(2000); // within 6ms
BOOST_CHECK(d < r); // within 6ms
}
void fn9( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.lock();
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(2500)+ms(2000)); // within 2.5 ms
}
void fn10( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock()) ;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(50000)+ms(2000)); // within 50 ms
}
void fn11( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(300)+ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn12( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_for(ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(5000)+ms(2000)); // within 5 ms
}
void fn13( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(300) + ms(1000)) == true);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn14( boost::fibers::recursive_timed_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock_until(std::chrono::steady_clock::now() + ms(250)) == false);
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(5000000)+ms(2000)); // within 5 ms
}
void fn15( boost::fibers::recursive_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.lock();
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(2500000)+ms(2000)); // within 2.5 ms
}
void fn16( boost::fibers::recursive_mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock());
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
BOOST_CHECK(m.try_lock());
m.unlock();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
void fn17( boost::fibers::mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
m.lock();
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ms(2500)+ms(2000)); // within 2.5 ms
}
void fn18( boost::fibers::mutex & m) {
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
while (!m.try_lock()) ;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
BOOST_CHECK(d < ns(50000000)+ms(2000)); // within 50 ms
}
template< typename M >
struct test_lock {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
mutex_type mtx;
// Test the lock's constructors.
{
lock_type lk(mtx, std::defer_lock);
BOOST_CHECK(!lk);
}
lock_type lk(mtx);
BOOST_CHECK(lk ? true : false);
// Test the lock and unlock methods.
lk.unlock();
BOOST_CHECK(!lk);
lk.lock();
BOOST_CHECK(lk ? true : false);
}
};
template< typename M >
struct test_exclusive {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
value1 = 0;
value2 = 0;
BOOST_CHECK_EQUAL( 0, value1);
BOOST_CHECK_EQUAL( 0, value2);
mutex_type mtx;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, & fn1< mutex_type >, std::ref( mtx) );
boost::fibers::fiber f2( boost::fibers::launch::dispatch, & fn2< mutex_type >, std::ref( mtx) );
BOOST_ASSERT( f1.joinable() );
BOOST_ASSERT( f2.joinable() );
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
BOOST_CHECK_EQUAL( 2, value2);
}
};
template< typename M >
struct test_recursive_lock {
typedef M mutex_type;
typedef typename std::unique_lock< M > lock_type;
void operator()() {
mutex_type mx;
lock_type lock1(mx);
lock_type lock2(mx);
}
};
void do_test_mutex() {
test_lock< boost::fibers::mutex >()();
test_exclusive< boost::fibers::mutex >()();
{
boost::fibers::mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn17, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
{
boost::fibers::mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn18, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
}
void test_mutex() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_mutex).join();
}
void do_test_recursive_mutex() {
test_lock< boost::fibers::recursive_mutex >()();
test_exclusive< boost::fibers::recursive_mutex >()();
test_recursive_lock< boost::fibers::recursive_mutex >()();
{
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn15, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
{
boost::fibers::recursive_mutex mtx;
mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn16, std::ref( mtx) );
boost::this_fiber::sleep_for( ms(250) );
mtx.unlock();
f.join();
}
}
void test_recursive_mutex() {
boost::fibers::fiber( boost::fibers::launch::dispatch, do_test_recursive_mutex).join();
}
void do_test_timed_mutex() {
test_lock< boost::fibers::timed_mutex >()();
test_exclusive< boost::fibers::timed_mutex >()();
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn3, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn4, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn5, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn6, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn7, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn8, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) + ms(1000) );
timed_mtx.unlock();
f.join();
}
}
void test_timed_mutex() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_timed_mutex).join();
}
void do_test_recursive_timed_mutex() {
test_lock< boost::fibers::recursive_timed_mutex >()();
test_exclusive< boost::fibers::recursive_timed_mutex >()();
test_recursive_lock< boost::fibers::recursive_timed_mutex >()();
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn9, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn10, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn11, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn12, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(400) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn13, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(250) );
timed_mtx.unlock();
f.join();
}
{
boost::fibers::recursive_timed_mutex timed_mtx;
timed_mtx.lock();
boost::fibers::fiber f( boost::fibers::launch::dispatch, & fn14, std::ref( timed_mtx) );
boost::this_fiber::sleep_for( ms(300) );
timed_mtx.unlock();
f.join();
}
}
void test_recursive_timed_mutex() {
boost::fibers::fiber( boost::fibers::launch::dispatch, & do_test_recursive_timed_mutex).join();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: mutex test suite");
test->add( BOOST_TEST_CASE( & test_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_mutex) );
test->add( BOOST_TEST_CASE( & test_timed_mutex) );
test->add( BOOST_TEST_CASE( & test_recursive_timed_mutex) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_future_dispatch.cpp | // (C) Copyright 2008-10 Anthony Williams
// 2015 Oliver Kowalke
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::milliseconds ms;
typedef std::chrono::high_resolution_clock Clock;
int gi = 7;
struct my_exception : public std::runtime_error {
my_exception() :
std::runtime_error("my_exception") {
}
};
struct A {
A() = default;
A( A const&) = delete;
A( A &&) = default;
A & operator=( A const&) = delete;
A & operator=( A &&) = default;
int value;
};
void fn1( boost::fibers::promise< int > * p, int i) {
boost::this_fiber::yield();
p->set_value( i);
}
void fn2() {
boost::fibers::promise< int > p;
boost::fibers::future< int > f( p.get_future() );
boost::this_fiber::yield();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn1, & p, 7).detach();
boost::this_fiber::yield();
BOOST_CHECK( 7 == f.get() );
}
int fn3() {
return 3;
}
void fn4() {
}
int fn5() {
boost::throw_exception( my_exception() );
return 3;
}
void fn6() {
boost::throw_exception( my_exception() );
}
int & fn7() {
return gi;
}
int fn8( int i) {
return i;
}
A fn9() {
A a;
a.value = 3;
return a;
}
A fn10() {
boost::throw_exception( my_exception() );
return A();
}
void fn11( boost::fibers::promise< int > p) {
boost::this_fiber::sleep_for( ms(500) );
p.set_value(3);
}
void fn12( boost::fibers::promise< int& > p) {
boost::this_fiber::sleep_for( ms(500) );
gi = 5;
p.set_value( gi);
}
void fn13( boost::fibers::promise< void > p) {
boost::this_fiber::sleep_for( ms(400) );
p.set_value();
}
// future
void test_future_create() {
// default constructed future is not valid
boost::fibers::future< int > f1;
BOOST_CHECK( ! f1.valid() );
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p2;
boost::fibers::future< int > f2 = p2.get_future();
BOOST_CHECK( f2.valid() );
}
void test_future_create_ref() {
// default constructed future is not valid
boost::fibers::future< int& > f1;
BOOST_CHECK( ! f1.valid() );
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p2;
boost::fibers::future< int& > f2 = p2.get_future();
BOOST_CHECK( f2.valid() );
}
void test_future_create_void() {
// default constructed future is not valid
boost::fibers::future< void > f1;
BOOST_CHECK( ! f1.valid() );
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p2;
boost::fibers::future< void > f2 = p2.get_future();
BOOST_CHECK( f2.valid() );
}
void test_future_move() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::future< int > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_future_move_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::future< int& > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_future_move_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// move construction
boost::fibers::future< void > f2( std::move( f1) );
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( f2.valid() );
// move assignment
f1 = std::move( f2);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( ! f2.valid() );
}
void test_future_get() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
p1.set_value( 7);
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
BOOST_CHECK( 7 == f1.get() );
BOOST_CHECK( ! f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< int > p2;
f1 = p2.get_future();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( thrown);
}
void test_future_get_move() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< A > p1;
A a; a.value = 7;
p1.set_value( std::move( a) );
boost::fibers::future< A > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
BOOST_CHECK( 7 == f1.get().value);
BOOST_CHECK( ! f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< A > p2;
f1 = p2.get_future();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( thrown);
}
void test_future_get_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
int i = 7;
p1.set_value( i);
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
int & j = f1.get();
BOOST_CHECK( &i == &j);
BOOST_CHECK( ! f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< int& > p2;
f1 = p2.get_future();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( thrown);
}
void test_future_get_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
p1.set_value();
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// get
BOOST_CHECK( ! f1.get_exception_ptr() );
f1.get();
BOOST_CHECK( ! f1.valid() );
// throw broken_promise if promise is destroyed without set
{
boost::fibers::promise< void > p2;
f1 = p2.get_future();
}
bool thrown = false;
try {
f1.get();
} catch ( boost::fibers::broken_promise const&) {
thrown = true;
}
BOOST_CHECK( ! f1.valid() );
BOOST_CHECK( thrown);
}
void test_future_share() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
int i = 7;
p1.set_value( i);
boost::fibers::future< int > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< int > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
int j = sf1.get();
BOOST_CHECK_EQUAL( i, j);
BOOST_CHECK( sf1.valid() );
}
void test_future_share_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
int i = 7;
p1.set_value( i);
boost::fibers::future< int& > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< int& > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
int & j = sf1.get();
BOOST_CHECK( &i == &j);
BOOST_CHECK( sf1.valid() );
}
void test_future_share_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
p1.set_value();
boost::fibers::future< void > f1 = p1.get_future();
BOOST_CHECK( f1.valid() );
// share
boost::fibers::shared_future< void > sf1 = f1.share();
BOOST_CHECK( sf1.valid() );
BOOST_CHECK( ! f1.valid() );
// get
BOOST_CHECK( ! sf1.get_exception_ptr() );
sf1.get();
BOOST_CHECK( sf1.valid() );
}
void test_future_wait() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
// wait on future
p1.set_value( 7);
f1.wait();
BOOST_CHECK( 7 == f1.get() );
}
void test_future_wait_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
// wait on future
int i = 7;
p1.set_value( i);
f1.wait();
int & j = f1.get();
BOOST_CHECK( &i == &j);
}
void test_future_wait_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
// wait on future
p1.set_value();
f1.wait();
f1.get();
BOOST_CHECK( ! f1.valid() );
}
void test_future_wait_for() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn11, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_for_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn12, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_for_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn13, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_for( ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_for( ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_until() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int > p1;
boost::fibers::future< int > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn11, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_until_ref() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< int& > p1;
boost::fibers::future< int& > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn12, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_until_void() {
// future retrieved from promise is valid (if it is the first)
boost::fibers::promise< void > p1;
boost::fibers::future< void > f1 = p1.get_future();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn13, std::move( p1) ).detach();
// wait on future
BOOST_CHECK( f1.valid() );
boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) );
BOOST_CHECK( boost::fibers::future_status::timeout == status);
BOOST_CHECK( f1.valid() );
status = f1.wait_until( Clock::now() + ms(400) );
BOOST_CHECK( boost::fibers::future_status::ready == status);
BOOST_CHECK( f1.valid() );
f1.wait();
}
void test_future_wait_with_fiber_1() {
boost::fibers::promise< int > p1;
boost::fibers::fiber( boost::fibers::launch::dispatch, fn1, & p1, 7).detach();
boost::fibers::future< int > f1 = p1.get_future();
// wait on future
BOOST_CHECK( 7 == f1.get() );
}
void test_future_wait_with_fiber_2() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fn2).join();
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: future test suite");
test->add(BOOST_TEST_CASE(test_future_create));
test->add(BOOST_TEST_CASE(test_future_create_ref));
test->add(BOOST_TEST_CASE(test_future_create_void));
test->add(BOOST_TEST_CASE(test_future_move));
test->add(BOOST_TEST_CASE(test_future_move_ref));
test->add(BOOST_TEST_CASE(test_future_move_void));
test->add(BOOST_TEST_CASE(test_future_get));
test->add(BOOST_TEST_CASE(test_future_get_move));
test->add(BOOST_TEST_CASE(test_future_get_ref));
test->add(BOOST_TEST_CASE(test_future_get_void));
test->add(BOOST_TEST_CASE(test_future_share));
test->add(BOOST_TEST_CASE(test_future_share_ref));
test->add(BOOST_TEST_CASE(test_future_share_void));
test->add(BOOST_TEST_CASE(test_future_wait));
test->add(BOOST_TEST_CASE(test_future_wait_ref));
test->add(BOOST_TEST_CASE(test_future_wait_void));
test->add(BOOST_TEST_CASE(test_future_wait_for));
test->add(BOOST_TEST_CASE(test_future_wait_for_ref));
test->add(BOOST_TEST_CASE(test_future_wait_for_void));
test->add(BOOST_TEST_CASE(test_future_wait_until));
test->add(BOOST_TEST_CASE(test_future_wait_until_ref));
test->add(BOOST_TEST_CASE(test_future_wait_until_void));
test->add(BOOST_TEST_CASE(test_future_wait_with_fiber_1));
test->add(BOOST_TEST_CASE(test_future_wait_with_fiber_2));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_fiber_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <mutex>
#include <sstream>
#include <string>
#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int value1 = 0;
std::string value2 = "";
struct X {
int value;
void foo( int i) {
value = i;
}
};
class copyable {
public:
bool state;
int value;
copyable() :
state( false),
value( -1) {
}
copyable( int v) :
state( true),
value( v) {
}
void operator()() {
value1 = value;
}
};
class moveable {
public:
bool state;
int value;
moveable() :
state( false),
value( -1) {
}
moveable( int v) :
state( true),
value( v) {
}
moveable( moveable && other) :
state( other.state),
value( other.value) {
other.state = false;
other.value = -1;
}
moveable & operator=( moveable && other) {
if ( this == & other) return * this;
state = other.state;
value = other.value;
other.state = false;
other.value = -1;
return * this;
}
moveable( moveable const& other) = delete;
moveable & operator=( moveable const& other) = delete;
void operator()() {
value1 = value;
}
};
class detachable {
private:
int alive_count_;
public:
static int alive_count;
static bool was_running;
detachable() :
alive_count_( 1) {
++alive_count;
}
detachable( detachable const& g) :
alive_count_( g.alive_count_) {
++alive_count;
}
~detachable() {
alive_count_ = 0;
--alive_count;
}
void operator()() {
BOOST_CHECK_EQUAL(1, alive_count_);
was_running = true;
}
};
int detachable::alive_count = 0;
bool detachable::was_running = false;
void fn1() {
value1 = 1;
}
void fn2( int i, std::string const& s) {
value1 = i;
value2 = s;
}
void fn3( int & i) {
i = 1;
boost::this_fiber::yield();
i = 1;
boost::this_fiber::yield();
i = 2;
boost::this_fiber::yield();
i = 3;
boost::this_fiber::yield();
i = 5;
boost::this_fiber::yield();
i = 8;
}
void fn4() {
boost::this_fiber::yield();
}
void fn5() {
boost::fibers::fiber f( boost::fibers::launch::post, fn4);
BOOST_CHECK( f.joinable() );
f.join();
BOOST_CHECK( ! f.joinable() );
}
void test_scheduler_dtor() {
boost::fibers::context * ctx(
boost::fibers::context::active() );
(void)ctx;
}
void test_join_fn() {
{
value1 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, fn1);
f.join();
BOOST_CHECK_EQUAL( value1, 1);
}
{
value1 = 0;
value2 = "";
boost::fibers::fiber f( boost::fibers::launch::post, fn2, 3, "abc");
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_memfn() {
X x = {0};
BOOST_CHECK_EQUAL( x.value, 0);
boost::fibers::fiber( boost::fibers::launch::post, & X::foo, & x, 3).join();
BOOST_CHECK_EQUAL( x.value, 3);
}
void test_join_copyable() {
value1 = 0;
copyable cp( 3);
BOOST_CHECK( cp.state);
BOOST_CHECK_EQUAL( value1, 0);
boost::fibers::fiber f( boost::fibers::launch::post, cp);
f.join();
BOOST_CHECK( cp.state);
BOOST_CHECK_EQUAL( value1, 3);
}
void test_join_moveable() {
value1 = 0;
moveable mv( 7);
BOOST_CHECK( mv.state);
BOOST_CHECK_EQUAL( value1, 0);
boost::fibers::fiber f( boost::fibers::launch::post, std::move( mv) );
f.join();
BOOST_CHECK( ! mv.state);
BOOST_CHECK_EQUAL( value1, 7);
}
void test_join_lambda() {
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::post, [i,abc]() {
value1 = i;
value2 = abc;
});
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::post, [](int i, std::string const& abc) {
value1 = i;
value2 = abc;
},
i, abc);
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_bind() {
{
value1 = 0;
value2 = "";
int i = 3;
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::post, std::bind(
[i,abc]() {
value1 = i;
value2 = abc;
}
));
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::post, std::bind(
[](std::string & str) {
value1 = 3;
value2 = str;
},
abc
));
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
{
value1 = 0;
value2 = "";
std::string abc("abc");
boost::fibers::fiber f(
boost::fibers::launch::post, std::bind(
[]( std::string & str) {
value1 = 3;
value2 = str;
},
std::placeholders::_1
),
std::ref( abc) );
f.join();
BOOST_CHECK_EQUAL( value1, 3);
BOOST_CHECK_EQUAL( value2, "abc");
}
}
void test_join_in_fiber() {
// spawn fiber f
// f spawns an new fiber f' in its fiber-fn
// f' yields in its fiber-fn
// f joins s' and gets suspended (waiting on s')
boost::fibers::fiber f( boost::fibers::launch::post, fn5);
BOOST_CHECK( f.joinable() );
// join() resumes f + f' which completes
f.join();
BOOST_CHECK( ! f.joinable() );
}
void test_move_fiber() {
boost::fibers::fiber f1;
BOOST_CHECK( ! f1.joinable() );
boost::fibers::fiber f2( boost::fibers::launch::post, fn1);
BOOST_CHECK( f2.joinable() );
f1 = std::move( f2);
BOOST_CHECK( f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
f1.join();
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
}
void test_id() {
boost::fibers::fiber f1;
boost::fibers::fiber f2( boost::fibers::launch::post, fn1);
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( f2.joinable() );
BOOST_CHECK_EQUAL( boost::fibers::fiber::id(), f1.get_id() );
BOOST_CHECK( boost::fibers::fiber::id() != f2.get_id() );
boost::fibers::fiber f3( boost::fibers::launch::post, fn1);
BOOST_CHECK( f2.get_id() != f3.get_id() );
f1 = std::move( f2);
BOOST_CHECK( f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
BOOST_CHECK( boost::fibers::fiber::id() != f1.get_id() );
BOOST_CHECK_EQUAL( boost::fibers::fiber::id(), f2.get_id() );
BOOST_CHECK( ! f2.joinable() );
f1.join();
f3.join();
}
void test_yield() {
int v1 = 0, v2 = 0;
BOOST_CHECK_EQUAL( 0, v1);
BOOST_CHECK_EQUAL( 0, v2);
boost::fibers::fiber f1( boost::fibers::launch::post, fn3, std::ref( v1) );
boost::fibers::fiber f2( boost::fibers::launch::post, fn3, std::ref( v2) );
f1.join();
f2.join();
BOOST_CHECK( ! f1.joinable() );
BOOST_CHECK( ! f2.joinable() );
BOOST_CHECK_EQUAL( 8, v1);
BOOST_CHECK_EQUAL( 8, v2);
}
void test_sleep_for() {
typedef std::chrono::system_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_for(ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the fiber system switches the fiber
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
void test_sleep_until() {
{
typedef std::chrono::steady_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_until(t0 + ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the thread system switches the threads
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
{
typedef std::chrono::system_clock Clock;
typedef Clock::time_point time_point;
std::chrono::milliseconds ms(500);
time_point t0 = Clock::now();
boost::this_fiber::sleep_until(t0 + ms);
time_point t1 = Clock::now();
std::chrono::nanoseconds ns = (t1 - t0) - ms;
std::chrono::nanoseconds err = ms / 10;
// This test is spurious as it depends on the time the thread system switches the threads
BOOST_CHECK((std::max)(ns.count(), -ns.count()) < (err+std::chrono::milliseconds(1000)).count());
}
}
void do_wait( boost::fibers::barrier* b) {
b->wait();
}
void test_detach() {
{
boost::fibers::fiber f( boost::fibers::launch::post, (detachable()) );
BOOST_CHECK( f.joinable() );
f.detach();
BOOST_CHECK( ! f.joinable() );
boost::this_fiber::sleep_for( std::chrono::milliseconds(250) );
BOOST_CHECK( detachable::was_running);
BOOST_CHECK_EQUAL( 0, detachable::alive_count);
}
{
boost::fibers::fiber f( boost::fibers::launch::post, (detachable()) );
BOOST_CHECK( f.joinable() );
boost::this_fiber::yield();
f.detach();
BOOST_CHECK( ! f.joinable() );
boost::this_fiber::sleep_for( std::chrono::milliseconds(250) );
BOOST_CHECK( detachable::was_running);
BOOST_CHECK_EQUAL( 0, detachable::alive_count);
}
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: fiber test suite");
test->add( BOOST_TEST_CASE( & test_scheduler_dtor) );
test->add( BOOST_TEST_CASE( & test_join_fn) );
test->add( BOOST_TEST_CASE( & test_join_memfn) );
test->add( BOOST_TEST_CASE( & test_join_copyable) );
test->add( BOOST_TEST_CASE( & test_join_moveable) );
test->add( BOOST_TEST_CASE( & test_join_lambda) );
test->add( BOOST_TEST_CASE( & test_join_bind) );
test->add( BOOST_TEST_CASE( & test_join_in_fiber) );
test->add( BOOST_TEST_CASE( & test_move_fiber) );
test->add( BOOST_TEST_CASE( & test_yield) );
test->add( BOOST_TEST_CASE( & test_sleep_for) );
test->add( BOOST_TEST_CASE( & test_sleep_until) );
test->add( BOOST_TEST_CASE( & test_detach) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_async_post.cpp | // (C) Copyright 2008-10 Anthony Williams
// 2015 Oliver Kowalke
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
struct A {
A() = default;
A( A const&) = delete;
A & operator=( A const&) = delete;
A( A && other) :
value{ other.value } {
other.value = 0;
}
A & operator=( A && other) {
if ( this == & other) return * this;
value = other.value;
other.value = 0;
return * this;
}
int value{ 0 };
};
struct X {
int value;
void foo( int i) {
value = i;
}
};
void fn1() {
}
int fn2( int i) {
return i;
}
int & fn3( int & i) {
return i;
}
A fn4( A && a) {
return std::forward< A >( a);
}
void test_async_1() {
boost::fibers::future< void > f1 = boost::fibers::async( boost::fibers::launch::post, fn1);
BOOST_CHECK( f1.valid() );
f1.get();
}
void test_async_2() {
int i = 3;
boost::fibers::future< int > f1 = boost::fibers::async( boost::fibers::launch::post, fn2, i);
BOOST_CHECK( f1.valid() );
BOOST_CHECK( i == f1.get());
}
void test_async_3() {
int i = 7;
boost::fibers::future< int& > f1 = boost::fibers::async( boost::fibers::launch::post, fn3, std::ref( i) );
BOOST_CHECK( f1.valid() );
BOOST_CHECK( & i == & f1.get());
}
void test_async_4() {
A a1;
a1.value = 7;
boost::fibers::future< A > f1 = boost::fibers::async( boost::fibers::launch::post, fn4, std::move( a1) );
BOOST_CHECK( f1.valid() );
A a2 = f1.get();
BOOST_CHECK( 7 == a2.value);
}
void test_async_5() {
X x = {0};
BOOST_CHECK( 0 == x.value);
boost::fibers::future< void > f1 = boost::fibers::async(
boost::fibers::launch::post,
std::bind( & X::foo, std::ref( x), 3) );
BOOST_CHECK( f1.valid() );
f1.get();
BOOST_CHECK( 3 == x.value);
}
void test_async_6() {
X x = {0};
BOOST_CHECK( 0 == x.value);
boost::fibers::future< void > f1 = boost::fibers::async(
boost::fibers::launch::post,
std::bind( & X::foo, std::ref( x), std::placeholders::_1), 3);
BOOST_CHECK( f1.valid() );
f1.get();
BOOST_CHECK( 3 == x.value);
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: async test suite");
test->add(BOOST_TEST_CASE(test_async_1));
test->add(BOOST_TEST_CASE(test_async_2));
test->add(BOOST_TEST_CASE(test_async_3));
test->add(BOOST_TEST_CASE(test_async_4));
test->add(BOOST_TEST_CASE(test_async_5));
test->add(BOOST_TEST_CASE(test_async_6));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_packaged_task_dispatch.cpp | // (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int gi = 7;
struct my_exception : public std::runtime_error {
my_exception() :
std::runtime_error("my_exception") {
}
};
struct A {
A() = default;
A( A const&) = delete;
A( A &&) = default;
A & operator=( A const&) = delete;
A & operator=( A &&) = default;
int value;
};
struct B {
bool bset{ false };
B() = default;
B( bool set) :
bset{ set } {
gi = 3;
}
~B() {
if ( bset) {
gi = -1;
}
}
B( B && other) :
bset{ other.bset } {
other.bset = false;
}
B & operator=( B && other) {
if ( this == & other) return * this;
bset = other.bset;
other.bset = false;
return * this;
}
B( B const&) = delete;
B & operator=( B const&) = delete;
};
void fn1( boost::fibers::promise< int > * p, int i) {
boost::this_fiber::yield();
p->set_value( i);
}
void fn2() {
boost::fibers::promise< int > p;
boost::fibers::future< int > f( p.get_future() );
boost::this_fiber::yield();
boost::fibers::fiber( boost::fibers::launch::dispatch, fn1, & p, 7).detach();
boost::this_fiber::yield();
BOOST_CHECK( 7 == f.get() );
}
int fn3() {
return 3;
}
void fn4() {
}
int fn5() {
boost::throw_exception( my_exception() );
return 3;
}
void fn6() {
boost::throw_exception( my_exception() );
}
int & fn7() {
return gi;
}
int fn8( int i) {
return i;
}
A fn9() {
A a;
a.value = 3;
return a;
}
A fn10() {
boost::throw_exception( my_exception() );
return A();
}
B fn11( bool set) {
B b( set);
return b;
}
// packaged_task
void test_packaged_task_create() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< int() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< int() > t2( fn3);
BOOST_CHECK( t2.valid() );
}
// packaged_task
void test_packaged_task_create_move() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< A() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< A() > t2( fn9);
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_create_void() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< void() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< void() > t2( fn4);
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_move() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< int() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_move_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< A() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_move_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< void() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_swap() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< int() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_swap_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< A() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_swap_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< void() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_reset() {
{
boost::fibers::packaged_task< int() > p( fn3);
boost::fibers::future< int > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
BOOST_CHECK( 3 == f.get() );
// reset
p.reset();
p();
f = p.get_future();
BOOST_CHECK( 3 == f.get() );
}
{
boost::fibers::packaged_task< int() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_reset_destruction() {
gi = 0;
boost::fibers::packaged_task< B( bool) > p( fn11);
BOOST_CHECK( p.valid() );
BOOST_CHECK( 0 == gi);
p( true);
BOOST_CHECK( 3 == gi);
// reset
p.reset();
BOOST_CHECK( -1 == gi);
p( false);
BOOST_CHECK( 3 == gi);
// reset
p.reset();
BOOST_CHECK( 3 == gi);
}
void test_packaged_task_reset_move() {
{
boost::fibers::packaged_task< A() > p( fn9);
boost::fibers::future< A > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
BOOST_CHECK( 3 == f.get().value);
// reset
p.reset();
p();
f = p.get_future();
BOOST_CHECK( 3 == f.get().value);
}
{
boost::fibers::packaged_task< A() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_reset_void() {
{
boost::fibers::packaged_task< void() > p( fn4);
boost::fibers::future< void > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
f.get();
// reset
p.reset();
p();
f = p.get_future();
f.get();
}
{
boost::fibers::packaged_task< void() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_get_future() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< int() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_get_future_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< A() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_get_future_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< void() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
BOOST_CHECK( 3 == f1.get() );
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec_move() {
// promise takes a copyable as return type
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
BOOST_CHECK( 3 == f1.get().value);
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec_param() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int( int) > t1( fn8);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1( 3);
BOOST_CHECK( 3 == f1.get() );
// exec a second time
bool thrown = false;
try {
t1( 7);
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
//TODO: packaged_task returns a moveable-only as return type
}
void test_packaged_task_exec_ref() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int&() > t1( fn7);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int& > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
int & i = f1.get();
BOOST_CHECK( &gi == &i);
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
//TODO: packaged_task returns a moveable-only as return type
}
void test_packaged_task_exec_void() {
// promise takes a copyable as return type
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// set void
t1();
f1.get();
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exception() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int() > t1( fn5);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< int() > t2( fn5);
BOOST_CHECK( t2.valid() );
boost::fibers::future< int > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try
{ std::rethrow_exception( f2.get_exception_ptr() ); }
catch ( my_exception const&)
{ thrown = true; }
BOOST_CHECK( thrown);
}
void test_packaged_task_exception_move() {
// promise takes a moveable as return type
boost::fibers::packaged_task< A() > t1( fn10);
BOOST_CHECK( t1.valid() );
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< A() > t2( fn10);
BOOST_CHECK( t2.valid() );
boost::fibers::future< A > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try
{ std::rethrow_exception( f2.get_exception_ptr() ); }
catch ( my_exception const&)
{ thrown = true; }
BOOST_CHECK( thrown);
}
void test_packaged_task_exception_void() {
// promise takes a copyable as return type
boost::fibers::packaged_task< void() > t1( fn6);
BOOST_CHECK( t1.valid() );
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// set void
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< void() > t2( fn6);
BOOST_CHECK( t2.valid() );
boost::fibers::future< void > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try {
std::rethrow_exception( f2.get_exception_ptr() );
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: packaged_task test suite");
test->add(BOOST_TEST_CASE(test_packaged_task_create));
test->add(BOOST_TEST_CASE(test_packaged_task_create_move));
test->add(BOOST_TEST_CASE(test_packaged_task_create_void));
test->add(BOOST_TEST_CASE(test_packaged_task_move));
test->add(BOOST_TEST_CASE(test_packaged_task_move_move));
test->add(BOOST_TEST_CASE(test_packaged_task_move_void));
test->add(BOOST_TEST_CASE(test_packaged_task_swap));
test->add(BOOST_TEST_CASE(test_packaged_task_swap_move));
test->add(BOOST_TEST_CASE(test_packaged_task_swap_void));
test->add(BOOST_TEST_CASE(test_packaged_task_reset));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_destruction));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_move));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_void));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future_move));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future_void));
test->add(BOOST_TEST_CASE(test_packaged_task_exec));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_move));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_param));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_ref));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_void));
test->add(BOOST_TEST_CASE(test_packaged_task_exception));
test->add(BOOST_TEST_CASE(test_packaged_task_exception_move));
test->add(BOOST_TEST_CASE(test_packaged_task_exception_void));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_packaged_task_post.cpp | // (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
int gi = 7;
struct my_exception : public std::runtime_error {
my_exception() :
std::runtime_error("my_exception") {
}
};
struct A {
A() = default;
A( A const&) = delete;
A( A &&) = default;
A & operator=( A const&) = delete;
A & operator=( A &&) = default;
int value;
};
struct B {
bool bset{ false };
B() = default;
B( bool set) :
bset{ set } {
gi = 3;
}
~B() {
if ( bset) {
gi = -1;
}
}
B( B && other) :
bset{ other.bset } {
other.bset = false;
}
B & operator=( B && other) {
if ( this == & other) return * this;
bset = other.bset;
other.bset = false;
return * this;
}
B( B const&) = delete;
B & operator=( B const&) = delete;
};
void fn1( boost::fibers::promise< int > * p, int i) {
boost::this_fiber::yield();
p->set_value( i);
}
void fn2() {
boost::fibers::promise< int > p;
boost::fibers::future< int > f( p.get_future() );
boost::this_fiber::yield();
boost::fibers::fiber( boost::fibers::launch::post, fn1, & p, 7).detach();
boost::this_fiber::yield();
BOOST_CHECK( 7 == f.get() );
}
int fn3() {
return 3;
}
void fn4() {
}
int fn5() {
boost::throw_exception( my_exception() );
return 3;
}
void fn6() {
boost::throw_exception( my_exception() );
}
int & fn7() {
return gi;
}
int fn8( int i) {
return i;
}
A fn9() {
A a;
a.value = 3;
return a;
}
A fn10() {
boost::throw_exception( my_exception() );
return A();
}
B fn11( bool set) {
B b( set);
return b;
}
// packaged_task
void test_packaged_task_create() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< int() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< int() > t2( fn3);
BOOST_CHECK( t2.valid() );
}
// packaged_task
void test_packaged_task_create_move() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< A() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< A() > t2( fn9);
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_create_void() {
// default constructed packaged_task is not valid
boost::fibers::packaged_task< void() > t1;
BOOST_CHECK( ! t1.valid() );
// packaged_task from function
boost::fibers::packaged_task< void() > t2( fn4);
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_move() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< int() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_move_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< A() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_move_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
// move construction
boost::fibers::packaged_task< void() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// move assignment
t1 = std::move( t2);
BOOST_CHECK( t1.valid() );
BOOST_CHECK( ! t2.valid() );
}
void test_packaged_task_swap() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< int() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_swap_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< A() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_swap_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
boost::fibers::packaged_task< void() > t2;
BOOST_CHECK( ! t2.valid() );
// swap
t1.swap( t2);
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
}
void test_packaged_task_reset() {
{
boost::fibers::packaged_task< int() > p( fn3);
boost::fibers::future< int > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
BOOST_CHECK( 3 == f.get() );
// reset
p.reset();
p();
f = p.get_future();
BOOST_CHECK( 3 == f.get() );
}
{
boost::fibers::packaged_task< int() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_reset_destruction() {
gi = 0;
boost::fibers::packaged_task< B( bool) > p( fn11);
BOOST_CHECK( p.valid() );
BOOST_CHECK( 0 == gi);
p( true);
BOOST_CHECK( 3 == gi);
// reset
p.reset();
BOOST_CHECK( -1 == gi);
p( false);
BOOST_CHECK( 3 == gi);
// reset
p.reset();
BOOST_CHECK( 3 == gi);
}
void test_packaged_task_reset_move() {
{
boost::fibers::packaged_task< A() > p( fn9);
boost::fibers::future< A > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
BOOST_CHECK( 3 == f.get().value);
// reset
p.reset();
p();
f = p.get_future();
BOOST_CHECK( 3 == f.get().value);
}
{
boost::fibers::packaged_task< A() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_reset_void() {
{
boost::fibers::packaged_task< void() > p( fn4);
boost::fibers::future< void > f( p.get_future() );
BOOST_CHECK( p.valid() );
p();
f.get();
// reset
p.reset();
p();
f = p.get_future();
f.get();
}
{
boost::fibers::packaged_task< void() > p;
bool thrown = false;
try {
p.reset();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
}
void test_packaged_task_get_future() {
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< int() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_get_future_move() {
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< A() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_get_future_void() {
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
// retrieve future
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// retrieve future a second time
bool thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::future_already_retrieved const&) {
thrown = true;
}
BOOST_CHECK( thrown);
// move construction
boost::fibers::packaged_task< void() > t2( std::move( t1) );
BOOST_CHECK( ! t1.valid() );
BOOST_CHECK( t2.valid() );
// retrieve future from uninitialized
thrown = false;
try {
f1 = t1.get_future();
} catch ( boost::fibers::packaged_task_uninitialized const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int() > t1( fn3);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
BOOST_CHECK( 3 == f1.get() );
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec_move() {
// promise takes a copyable as return type
boost::fibers::packaged_task< A() > t1( fn9);
BOOST_CHECK( t1.valid() );
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
BOOST_CHECK( 3 == f1.get().value);
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exec_param() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int( int) > t1( fn8);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1( 3);
BOOST_CHECK( 3 == f1.get() );
// exec a second time
bool thrown = false;
try {
t1( 7);
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
//TODO: packaged_task returns a moveable-only as return type
}
void test_packaged_task_exec_ref() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int&() > t1( fn7);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int& > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
int & i = f1.get();
BOOST_CHECK( &gi == &i);
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
//TODO: packaged_task returns a moveable-only as return type
}
void test_packaged_task_exec_void() {
// promise takes a copyable as return type
boost::fibers::packaged_task< void() > t1( fn4);
BOOST_CHECK( t1.valid() );
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// set void
t1();
f1.get();
// exec a second time
bool thrown = false;
try {
t1();
} catch ( boost::fibers::promise_already_satisfied const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_packaged_task_exception() {
// promise takes a copyable as return type
boost::fibers::packaged_task< int() > t1( fn5);
BOOST_CHECK( t1.valid() );
boost::fibers::future< int > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< int() > t2( fn5);
BOOST_CHECK( t2.valid() );
boost::fibers::future< int > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try
{ std::rethrow_exception( f2.get_exception_ptr() ); }
catch ( my_exception const&)
{ thrown = true; }
BOOST_CHECK( thrown);
}
void test_packaged_task_exception_move() {
// promise takes a moveable as return type
boost::fibers::packaged_task< A() > t1( fn10);
BOOST_CHECK( t1.valid() );
boost::fibers::future< A > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// exec
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< A() > t2( fn10);
BOOST_CHECK( t2.valid() );
boost::fibers::future< A > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try
{ std::rethrow_exception( f2.get_exception_ptr() ); }
catch ( my_exception const&)
{ thrown = true; }
BOOST_CHECK( thrown);
}
void test_packaged_task_exception_void() {
// promise takes a copyable as return type
boost::fibers::packaged_task< void() > t1( fn6);
BOOST_CHECK( t1.valid() );
boost::fibers::future< void > f1 = t1.get_future();
BOOST_CHECK( f1.valid() );
// set void
t1();
bool thrown = false;
try {
f1.get();
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
boost::fibers::packaged_task< void() > t2( fn6);
BOOST_CHECK( t2.valid() );
boost::fibers::future< void > f2 = t2.get_future();
BOOST_CHECK( f2.valid() );
// exec
t2();
BOOST_CHECK( f2.get_exception_ptr() );
thrown = false;
try {
std::rethrow_exception( f2.get_exception_ptr() );
} catch ( my_exception const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: packaged_task test suite");
test->add(BOOST_TEST_CASE(test_packaged_task_create));
test->add(BOOST_TEST_CASE(test_packaged_task_create_move));
test->add(BOOST_TEST_CASE(test_packaged_task_create_void));
test->add(BOOST_TEST_CASE(test_packaged_task_move));
test->add(BOOST_TEST_CASE(test_packaged_task_move_move));
test->add(BOOST_TEST_CASE(test_packaged_task_move_void));
test->add(BOOST_TEST_CASE(test_packaged_task_swap));
test->add(BOOST_TEST_CASE(test_packaged_task_swap_move));
test->add(BOOST_TEST_CASE(test_packaged_task_swap_void));
test->add(BOOST_TEST_CASE(test_packaged_task_reset));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_destruction));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_move));
test->add(BOOST_TEST_CASE(test_packaged_task_reset_void));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future_move));
test->add(BOOST_TEST_CASE(test_packaged_task_get_future_void));
test->add(BOOST_TEST_CASE(test_packaged_task_exec));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_move));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_param));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_ref));
test->add(BOOST_TEST_CASE(test_packaged_task_exec_void));
test->add(BOOST_TEST_CASE(test_packaged_task_exception));
test->add(BOOST_TEST_CASE(test_packaged_task_exception_move));
test->add(BOOST_TEST_CASE(test_packaged_task_exception_void));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_future_mt_dispatch.cpp | // (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <boost/fiber/all.hpp>
#include <boost/test/unit_test.hpp>
int fn( int i) {
return i;
}
void test_async() {
for ( int i = 0; i < 10; ++i) {
int n = 3;
boost::fibers::packaged_task< int( int) > pt( fn);
boost::fibers::future< int > f( pt.get_future() );
std::thread t(
std::bind(
[n](boost::fibers::packaged_task< int( int) > & pt) mutable -> void {
boost::fibers::fiber( boost::fibers::launch::dispatch, std::move( pt), n).join();
},
std::move( pt) ) );
int result = f.get();
BOOST_CHECK_EQUAL( n, result);
t.join();
}
}
void test_dummy() {}
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test_framework::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: futures-mt test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add(BOOST_TEST_CASE(test_async));
#else
test->add(BOOST_TEST_CASE(test_dummy));
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_fss_dispatch.cpp | // Copyright (C) 2001-2003
// William E. Kempf
// Copyright (C) 2007 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <mutex>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
boost::fibers::mutex check_mutex;
boost::fibers::mutex fss_mutex;
int fss_instances = 0;
int fss_total = 0;
struct fss_value_t {
fss_value_t() {
std::unique_lock<boost::fibers::mutex> lock(fss_mutex);
++fss_instances;
++fss_total;
value = 0;
}
~fss_value_t() {
std::unique_lock<boost::fibers::mutex> lock(fss_mutex);
--fss_instances;
}
int value;
};
boost::fibers::fiber_specific_ptr<fss_value_t> fss_value;
void fss_fiber() {
fss_value.reset(new fss_value_t());
for (int i=0; i<1000; ++i) {
int& n = fss_value->value;
if (n != i) {
std::unique_lock<boost::fibers::mutex> lock(check_mutex);
BOOST_CHECK_EQUAL(n, i);
}
++n;
}
}
void fss() {
fss_instances = 0;
fss_total = 0;
boost::fibers::fiber f1( boost::fibers::launch::dispatch, fss_fiber);
boost::fibers::fiber f2( boost::fibers::launch::dispatch, fss_fiber);
boost::fibers::fiber f3( boost::fibers::launch::dispatch, fss_fiber);
boost::fibers::fiber f4( boost::fibers::launch::dispatch, fss_fiber);
boost::fibers::fiber f5( boost::fibers::launch::dispatch, fss_fiber);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
std::cout
<< "fss_instances = " << fss_instances
<< "; fss_total = " << fss_total
<< "\n";
std::cout.flush();
BOOST_CHECK_EQUAL(fss_instances, 0);
BOOST_CHECK_EQUAL(fss_total, 5);
}
void test_fss() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fss).join();
}
bool fss_cleanup_called=false;
struct Dummy {
};
void fss_custom_cleanup(Dummy* d) {
delete d;
fss_cleanup_called=true;
}
boost::fibers::fiber_specific_ptr<Dummy> fss_with_cleanup(fss_custom_cleanup);
void fss_fiber_with_custom_cleanup() {
fss_with_cleanup.reset(new Dummy);
}
void fss_with_custom_cleanup() {
boost::fibers::fiber f( boost::fibers::launch::dispatch, fss_fiber_with_custom_cleanup);
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(fss_cleanup_called);
}
void test_fss_with_custom_cleanup() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fss_with_custom_cleanup).join();
}
Dummy* fss_object=new Dummy;
void fss_fiber_with_custom_cleanup_and_release() {
fss_with_cleanup.reset(fss_object);
fss_with_cleanup.release();
}
void do_test_fss_does_no_cleanup_after_release() {
fss_cleanup_called=false;
boost::fibers::fiber f( boost::fibers::launch::dispatch, fss_fiber_with_custom_cleanup_and_release);
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(!fss_cleanup_called);
if(!fss_cleanup_called) {
delete fss_object;
}
}
struct dummy_class_tracks_deletions {
static unsigned deletions;
~dummy_class_tracks_deletions() {
++deletions;
}
};
unsigned dummy_class_tracks_deletions::deletions=0;
boost::fibers::fiber_specific_ptr<dummy_class_tracks_deletions> fss_with_null_cleanup(NULL);
void fss_fiber_with_null_cleanup(dummy_class_tracks_deletions* delete_tracker) {
fss_with_null_cleanup.reset(delete_tracker);
}
void do_test_fss_does_no_cleanup_with_null_cleanup_function() {
dummy_class_tracks_deletions* delete_tracker=new dummy_class_tracks_deletions;
boost::fibers::fiber f( boost::fibers::launch::dispatch, [&delete_tracker](){
fss_fiber_with_null_cleanup( delete_tracker); });
try {
f.join();
} catch(...) {
f.join();
throw;
}
BOOST_CHECK(!dummy_class_tracks_deletions::deletions);
if(!dummy_class_tracks_deletions::deletions) {
delete delete_tracker;
}
}
void test_fss_does_no_cleanup_after_release() {
boost::fibers::fiber( boost::fibers::launch::dispatch, do_test_fss_does_no_cleanup_after_release).join();
}
void test_fss_does_no_cleanup_with_null_cleanup_function() {
boost::fibers::fiber( boost::fibers::launch::dispatch, do_test_fss_does_no_cleanup_with_null_cleanup_function).join();
}
void fiber_with_local_fss_ptr() {
{
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
}
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
}
void fss_does_not_call_cleanup_after_ptr_destroyed() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fiber_with_local_fss_ptr).join();
BOOST_CHECK(!fss_cleanup_called);
}
void test_fss_does_not_call_cleanup_after_ptr_destroyed() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fss_does_not_call_cleanup_after_ptr_destroyed).join();
}
void fss_cleanup_not_called_for_null_pointer() {
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
fss_cleanup_called=false;
local_fss.reset(0);
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
local_fss.reset(new Dummy);
BOOST_CHECK(!fss_cleanup_called);
}
void test_fss_cleanup_not_called_for_null_pointer() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fss_cleanup_not_called_for_null_pointer).join();
}
void fss_at_the_same_adress() {
for(int i=0; i<2; i++) {
boost::fibers::fiber_specific_ptr<Dummy> local_fss(fss_custom_cleanup);
local_fss.reset(new Dummy);
fss_cleanup_called=false;
BOOST_CHECK(fss_cleanup_called);
fss_cleanup_called=false;
BOOST_CHECK(!fss_cleanup_called);
}
}
void test_fss_at_the_same_adress() {
boost::fibers::fiber( boost::fibers::launch::dispatch, fss_at_the_same_adress).join();
}
boost::unit_test::test_suite* init_unit_test_suite(int, char*[]) {
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Fiber: fss test suite");
test->add(BOOST_TEST_CASE(test_fss));
test->add(BOOST_TEST_CASE(test_fss_with_custom_cleanup));
test->add(BOOST_TEST_CASE(test_fss_does_no_cleanup_after_release));
test->add(BOOST_TEST_CASE(test_fss_does_no_cleanup_with_null_cleanup_function));
test->add(BOOST_TEST_CASE(test_fss_does_not_call_cleanup_after_ptr_destroyed));
test->add(BOOST_TEST_CASE(test_fss_cleanup_not_called_for_null_pointer));
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_unbuffered_channel_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <chrono>
#include <sstream>
#include <string>
#include <vector>
#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
struct moveable {
bool state;
int value;
moveable() :
state( false),
value( -1) {
}
moveable( int v) :
state( true),
value( v) {
}
moveable( moveable && other) :
state( other.state),
value( other.value) {
other.state = false;
other.value = -1;
}
moveable & operator=( moveable && other) {
if ( this == & other) return * this;
state = other.state;
other.state = false;
value = other.value;
other.value = -1;
return * this;
}
};
void test_push() {
boost::fibers::unbuffered_channel< int > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
});
int value = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( value) );
BOOST_CHECK_EQUAL( 1, value);
f.join();
}
void test_push_closed() {
boost::fibers::unbuffered_channel< int > c;
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push( 1) );
}
void test_push_wait_for() {
boost::fibers::unbuffered_channel< int > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
});
int value = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( value) );
BOOST_CHECK_EQUAL( 1, value);
f.join();
}
void test_push_wait_for_closed() {
boost::fibers::unbuffered_channel< int > c;
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
}
void test_push_wait_for_timeout() {
boost::fibers::unbuffered_channel< int > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c](){
int value = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( value) );
BOOST_CHECK_EQUAL( 1, value);
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_for( 1, std::chrono::seconds( 1) ) );
f.join();
}
void test_push_wait_until() {
boost::fibers::unbuffered_channel< int > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
int value = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( value) );
BOOST_CHECK_EQUAL( 1, value);
f.join();
}
void test_push_wait_until_closed() {
boost::fibers::unbuffered_channel< int > c;
c.close();
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_push_wait_until_timeout() {
boost::fibers::unbuffered_channel< int > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c](){
int value = 0;
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( value) );
BOOST_CHECK_EQUAL( 1, value);
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.push_wait_until( 1,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
f.join();
}
void test_pop() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&v1,&c](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
f.join();
}
void test_pop_closed() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&v1,&c](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop( v2) );
f.join();
}
void test_pop_success() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( v2) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
v2 = c.value_pop();
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_value_pop_closed() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
});
int v2 = c.value_pop();
BOOST_CHECK_EQUAL( v1, v2);
f.join();
bool thrown = false;
try {
c.value_pop();
} catch ( boost::fibers::fiber_error const&) {
thrown = true;
}
BOOST_CHECK( thrown);
}
void test_value_pop_success() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v2](){
v2 = c.value_pop();
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_closed() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
f.join();
}
void test_pop_wait_for_success() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_for( v2, std::chrono::seconds( 1) ) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_for_timeout() {
boost::fibers::unbuffered_channel< int > c;
int v = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v](){
BOOST_CHECK( boost::fibers::channel_op_status::timeout == c.pop_wait_for( v, std::chrono::seconds( 1) ) );
});
f.join();
}
void test_pop_wait_until() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
f.join();
}
void test_pop_wait_until_closed() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v1](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
c.close();
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
BOOST_CHECK_EQUAL( v1, v2);
BOOST_CHECK( boost::fibers::channel_op_status::closed == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
f.join();
}
void test_pop_wait_until_success() {
boost::fibers::unbuffered_channel< int > c;
int v1 = 2, v2 = 0;
boost::fibers::fiber f( boost::fibers::launch::post, [&c,&v2](){
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop_wait_until( v2,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
});
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( v1) );
f.join();
BOOST_CHECK_EQUAL( v1, v2);
}
void test_pop_wait_until_timeout() {
boost::fibers::unbuffered_channel< int > c;
int v = 0;
BOOST_CHECK(
boost::fibers::channel_op_status::timeout == c.pop_wait_until( v,
std::chrono::system_clock::now() + std::chrono::seconds( 1) ) );
}
void test_wm_1() {
boost::fibers::unbuffered_channel< int > c;
std::vector< boost::fibers::fiber::id > ids;
boost::fibers::fiber f1( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 1) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 2) );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 3) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 4) );
ids.push_back( boost::this_fiber::get_id() );
// would be blocked because channel is full
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( 5) );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&c,&ids](){
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 1, c.value_pop() );
// let other fiber run
boost::this_fiber::yield();
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 2, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 3, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
BOOST_CHECK_EQUAL( 4, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
// would block because channel is empty
BOOST_CHECK_EQUAL( 5, c.value_pop() );
ids.push_back( boost::this_fiber::get_id() );
});
boost::fibers::fiber::id id1 = f1.get_id();
boost::fibers::fiber::id id2 = f2.get_id();
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 12u, ids.size() );
BOOST_CHECK_EQUAL( id1, ids[0]);
BOOST_CHECK_EQUAL( id2, ids[1]);
BOOST_CHECK_EQUAL( id1, ids[2]);
BOOST_CHECK_EQUAL( id2, ids[3]);
BOOST_CHECK_EQUAL( id2, ids[4]);
BOOST_CHECK_EQUAL( id1, ids[5]);
BOOST_CHECK_EQUAL( id2, ids[6]);
BOOST_CHECK_EQUAL( id1, ids[7]);
BOOST_CHECK_EQUAL( id2, ids[8]);
BOOST_CHECK_EQUAL( id1, ids[9]);
BOOST_CHECK_EQUAL( id2, ids[10]);
BOOST_CHECK_EQUAL( id1, ids[11]);
}
void test_moveable() {
boost::fibers::unbuffered_channel< moveable > c;
boost::fibers::fiber f( boost::fibers::launch::post, [&c]{
moveable m1( 3);
BOOST_CHECK( m1.state);
BOOST_CHECK_EQUAL( 3, m1.value);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.push( std::move( m1) ) );
});
moveable m2;
BOOST_CHECK( ! m2.state);
BOOST_CHECK_EQUAL( -1, m2.value);
BOOST_CHECK( boost::fibers::channel_op_status::success == c.pop( m2) );
BOOST_CHECK( m2.state);
BOOST_CHECK_EQUAL( 3, m2.value);
f.join();
}
void test_rangefor() {
boost::fibers::unbuffered_channel< int > chan;
std::vector< int > vec;
boost::fibers::fiber f1( boost::fibers::launch::post, [&chan]{
chan.push( 1);
chan.push( 1);
chan.push( 2);
chan.push( 3);
chan.push( 5);
chan.push( 8);
chan.push( 12);
chan.close();
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&vec,&chan]{
for ( int value : chan) {
vec.push_back( value);
}
});
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, vec[0]);
BOOST_CHECK_EQUAL( 1, vec[1]);
BOOST_CHECK_EQUAL( 2, vec[2]);
BOOST_CHECK_EQUAL( 3, vec[3]);
BOOST_CHECK_EQUAL( 5, vec[4]);
BOOST_CHECK_EQUAL( 8, vec[5]);
BOOST_CHECK_EQUAL( 12, vec[6]);
}
void test_issue_181() {
boost::fibers::unbuffered_channel< int > chan;
boost::fibers::fiber f1( boost::fibers::launch::post, [&chan]() {
auto state = chan.push( 1);
BOOST_CHECK( boost::fibers::channel_op_status::closed == state);
});
boost::fibers::fiber f2( boost::fibers::launch::post, [&chan]() {
boost::this_fiber::sleep_for( std::chrono::milliseconds( 100) );
chan.close();
});
f2.join();
f1.join();
}
void test_issue_268() {
boost::fibers::unbuffered_channel< int > chan;
std::vector< int > vec;
boost::fibers::fiber con( boost::fibers::launch::dispatch, [&]() {
int v;
while (chan.pop( v) == boost::fibers::channel_op_status::success) {
boost::this_fiber::yield();
vec.push_back( v);
}
});
boost::fibers::fiber p1( boost::fibers::launch::post, [&]() {
chan.push( 12);
});
chan.push( 22);
boost::this_fiber::sleep_for( std::chrono::milliseconds( 100) );
BOOST_CHECK_EQUAL( 2u, vec.size());
p1.join();
chan.close();
con.join();
BOOST_CHECK_EQUAL( 22, vec[0]);
BOOST_CHECK_EQUAL( 12, vec[1]);
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: unbuffered_channel test suite");
test->add( BOOST_TEST_CASE( & test_push) );
test->add( BOOST_TEST_CASE( & test_push_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_for) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_push_wait_until) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_push_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_pop) );
test->add( BOOST_TEST_CASE( & test_pop_closed) );
test->add( BOOST_TEST_CASE( & test_pop_success) );
test->add( BOOST_TEST_CASE( & test_value_pop) );
test->add( BOOST_TEST_CASE( & test_value_pop_closed) );
test->add( BOOST_TEST_CASE( & test_value_pop_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_for_timeout) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_closed) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_success) );
test->add( BOOST_TEST_CASE( & test_pop_wait_until_timeout) );
test->add( BOOST_TEST_CASE( & test_wm_1) );
test->add( BOOST_TEST_CASE( & test_moveable) );
test->add( BOOST_TEST_CASE( & test_rangefor) );
test->add( BOOST_TEST_CASE( & test_issue_181) );
test->add( BOOST_TEST_CASE( & test_issue_268) );
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_mt_dispatch.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <stdexcept>
#include <vector>
#include <boost/atomic.hpp>
#include <boost/bind.hpp>
#include <boost/chrono.hpp>
#include <boost/cstdint.hpp>
#include <boost/function.hpp>
#include <boost/ref.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread.hpp>
#include <boost/utility.hpp>
#include <boost/fiber/all.hpp>
typedef boost::chrono::milliseconds ms;
boost::atomic< int > value1;
void wait_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
cond.wait( lk, [&flag](){ return flag; });
++value1;
}
void notify_one_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
flag = true;
lk.unlock();
cond.notify_one();
}
void notify_all_fn( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
b.wait();
std::unique_lock< boost::fibers::mutex > lk( mtx);
flag = true;
lk.unlock();
cond.notify_all();
}
void fn1( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::dispatch,
wait_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void fn2( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::dispatch,
notify_one_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void fn3( boost::barrier & b,
boost::fibers::mutex & mtx,
boost::fibers::condition_variable & cond,
bool & flag) {
boost::fibers::fiber(
boost::fibers::launch::dispatch,
notify_all_fn,
std::ref( b),
std::ref( mtx),
std::ref( cond),
std::ref( flag) ).join();
}
void test_one_waiter_notify_one() {
for ( int i = 0; i < 10; ++i) {
boost::barrier b( 2);
bool flag = false;
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
BOOST_CHECK( 0 == value1);
boost::thread t1(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t2(std::bind( fn2, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
t1.join();
t2.join();
BOOST_CHECK( 1 == value1);
}
}
void test_two_waiter_notify_all() {
for ( int i = 0; i < 10; ++i) {
boost::barrier b( 3);
bool flag = false;
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable cond;
BOOST_CHECK( 0 == value1);
boost::thread t1(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t2(std::bind( fn1, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
boost::thread t3(std::bind( fn3, std::ref( b), std::ref( mtx), std::ref( cond), std::ref( flag) ) );
t1.join();
t2.join();
t3.join();
BOOST_CHECK( 2 == value1);
}
}
void test_dummy() {
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
{
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: multithreaded condition_variable test suite");
#if ! defined(BOOST_FIBERS_NO_ATOMICS)
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
#else
test->add( BOOST_TEST_CASE( & test_dummy) );
#endif
return test;
}
|
0 | repos/fiber | repos/fiber/test/test_condition_variable_any_post.cpp |
// Copyright Oliver Kowalke 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// This test is based on the tests of Boost.Thread
#include <chrono>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <map>
#include <stdexcept>
#include <vector>
#include <boost/test/unit_test.hpp>
#include <boost/fiber/all.hpp>
typedef std::chrono::nanoseconds ns;
typedef std::chrono::milliseconds ms;
int value1 = 0;
inline
std::chrono::system_clock::time_point delay(int secs, int msecs=0, int /*nsecs*/=0) {
std::chrono::system_clock::time_point t = std::chrono::system_clock::now();
t += std::chrono::seconds( secs);
t += std::chrono::milliseconds( msecs);
//t += std::chrono::nanoseconds( nsecs);
return t;
}
struct condition_test_data {
condition_test_data() : notified(0), awoken(0) { }
boost::fibers::mutex mutex;
boost::fibers::condition_variable_any cond;
int notified;
int awoken;
};
void condition_test_fiber(condition_test_data* data) {
try {
data->mutex.lock();
while (!(data->notified > 0))
data->cond.wait(data->mutex);
data->awoken++;
} catch ( ... ) {
}
data->mutex.unlock();
}
struct cond_predicate {
cond_predicate(int& var, int val) : _var(var), _val(val) { }
bool operator()() { return _var == _val; }
int& _var;
int _val;
private:
void operator=(cond_predicate&);
};
void notify_one_fn( boost::fibers::condition_variable_any & cond) {
cond.notify_one();
}
void notify_all_fn( boost::fibers::condition_variable_any & cond) {
cond.notify_all();
}
void wait_fn(
boost::fibers::mutex & mtx,
boost::fibers::condition_variable_any & cond) {
mtx.lock();
cond.wait( mtx);
++value1;
mtx.unlock();
}
void test_one_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
BOOST_CHECK_EQUAL( 1, value1);
}
void test_two_waiter_notify_one() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::post,
notify_one_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
f3.join();
f4.join();
BOOST_CHECK_EQUAL( 2, value1);
}
void test_two_waiter_notify_all() {
value1 = 0;
boost::fibers::mutex mtx;
boost::fibers::condition_variable_any cond;
boost::fibers::fiber f1(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f2(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f3(
boost::fibers::launch::post,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f4(
boost::fibers::launch::post,
wait_fn,
std::ref( mtx),
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
boost::fibers::fiber f5(
boost::fibers::launch::post,
notify_all_fn,
std::ref( cond) );
BOOST_CHECK_EQUAL( 0, value1);
f1.join();
f2.join();
f3.join();
f4.join();
f5.join();
BOOST_CHECK_EQUAL( 3, value1);
}
int test1 = 0;
int test2 = 0;
int runs = 0;
void fn1( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
while (test2 == 0) {
cv.wait(m);
}
BOOST_CHECK(test2 != 0);
m.unlock();
}
void fn2( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::system_clock::time_point t0 = std::chrono::system_clock::now();
std::chrono::system_clock::time_point t = t0 + ms(250);
int count=0;
while (test2 == 0 && cv.wait_until(m, t) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
class Pred {
int & i_;
public:
explicit Pred(int& i) :
i_(i)
{}
bool operator()()
{ return i_ != 0; }
};
void fn3( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point t = t0 + ms(250);
bool r = cv.wait_until(m, t, Pred(test2));
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
BOOST_CHECK(r);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(250+100));
BOOST_CHECK(test2 == 0);
BOOST_CHECK(!r);
}
++runs;
m.unlock();
}
void fn4( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
while (test2 == 0 && cv.wait_for(m, ms(250)) == boost::fibers::cv_status::no_timeout)
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100+1000));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
void fn5( boost::fibers::mutex & m, boost::fibers::condition_variable_any & cv) {
m.lock();
BOOST_CHECK(test2 == 0);
test1 = 1;
cv.notify_one();
std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
int count=0;
cv.wait_for(m, ms(250), Pred(test2));
count++;
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
if (runs == 0) {
BOOST_CHECK(t1 - t0 < ms(250+1000));
BOOST_CHECK(test2 != 0);
} else {
BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100));
BOOST_CHECK(test2 == 0);
}
++runs;
m.unlock();
}
void do_test_condition_wait() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn1, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
void test_condition_wait() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait).join();
do_test_condition_wait();
}
void do_test_condition_wait_until() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn2, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_until() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_until).join();
do_test_condition_wait_until();
}
void do_test_condition_wait_until_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn3, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_until_pred() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_until_pred).join();
do_test_condition_wait_until_pred();
}
void do_test_condition_wait_for() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn4, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_for() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_for).join();
do_test_condition_wait_for();
}
void do_test_condition_wait_for_pred() {
test1 = 0;
test2 = 0;
runs = 0;
boost::fibers::mutex m;
boost::fibers::condition_variable_any cv;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
test2 = 1;
m.unlock();
cv.notify_one();
f.join();
}
test1 = 0;
test2 = 0;
{
m.lock();
boost::fibers::fiber f( boost::fibers::launch::post, & fn5, std::ref( m), std::ref( cv) );
BOOST_CHECK(test1 == 0);
while (test1 == 0)
cv.wait(m);
BOOST_CHECK(test1 != 0);
m.unlock();
f.join();
}
}
void test_condition_wait_for_pred() {
boost::fibers::fiber( boost::fibers::launch::post, & do_test_condition_wait_for_pred).join();
do_test_condition_wait_for_pred();
}
boost::unit_test::test_suite * init_unit_test_suite( int, char* []) {
boost::unit_test::test_suite * test =
BOOST_TEST_SUITE("Boost.Fiber: condition_variable_any test suite");
test->add( BOOST_TEST_CASE( & test_one_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_one) );
test->add( BOOST_TEST_CASE( & test_two_waiter_notify_all) );
test->add( BOOST_TEST_CASE( & test_condition_wait) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until) );
test->add( BOOST_TEST_CASE( & test_condition_wait_until_pred) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for) );
test->add( BOOST_TEST_CASE( & test_condition_wait_for_pred) );
return test;
}
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.