317 lines
9.9 KiB
C++
317 lines
9.9 KiB
C++
// Comparison of bounded buffers based on different containers.
|
|
|
|
// Copyright (c) 2003-2008 Jan Gaspar
|
|
// Copyright 2013 Paul A. Bristow. Added some Quickbook snippet markers.
|
|
|
|
// Use, modification, and distribution is subject to 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/circular_buffer.hpp>
|
|
#include <boost/thread/mutex.hpp>
|
|
#include <boost/thread/condition.hpp>
|
|
#include <boost/thread/thread.hpp>
|
|
#include <boost/timer/timer.hpp>
|
|
#include <boost/call_traits.hpp>
|
|
#include <boost/bind.hpp>
|
|
#include <deque>
|
|
#include <list>
|
|
#include <string>
|
|
#include <iostream>
|
|
|
|
const unsigned long QUEUE_SIZE = 1000L;
|
|
const unsigned long TOTAL_ELEMENTS = QUEUE_SIZE * 1000L;
|
|
|
|
template <class T>
|
|
class bounded_buffer {
|
|
public:
|
|
|
|
typedef boost::circular_buffer<T> container_type;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename boost::call_traits<value_type>::param_type param_type;
|
|
|
|
explicit bounded_buffer(size_type capacity) : m_unread(0), m_container(capacity) {}
|
|
|
|
void push_front(param_type item) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_full.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this));
|
|
m_container.push_front(item);
|
|
++m_unread;
|
|
lock.unlock();
|
|
m_not_empty.notify_one();
|
|
}
|
|
|
|
void pop_back(value_type* pItem) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_empty.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this));
|
|
*pItem = m_container[--m_unread];
|
|
lock.unlock();
|
|
m_not_full.notify_one();
|
|
}
|
|
|
|
private:
|
|
bounded_buffer(const bounded_buffer&); // Disabled copy constructor
|
|
bounded_buffer& operator = (const bounded_buffer&); // Disabled assign operator
|
|
|
|
bool is_not_empty() const { return m_unread > 0; }
|
|
bool is_not_full() const { return m_unread < m_container.capacity(); }
|
|
|
|
size_type m_unread;
|
|
container_type m_container;
|
|
boost::mutex m_mutex;
|
|
boost::condition m_not_empty;
|
|
boost::condition m_not_full;
|
|
};
|
|
|
|
template <class T>
|
|
class bounded_buffer_space_optimized {
|
|
public:
|
|
|
|
typedef boost::circular_buffer_space_optimized<T> container_type;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename boost::call_traits<value_type>::param_type param_type;
|
|
|
|
explicit bounded_buffer_space_optimized(size_type capacity) : m_container(capacity) {}
|
|
|
|
void push_front(param_type item) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_full.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_full, this));
|
|
m_container.push_front(item);
|
|
lock.unlock();
|
|
m_not_empty.notify_one();
|
|
}
|
|
|
|
void pop_back(value_type* pItem) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_empty.wait(lock, boost::bind(&bounded_buffer_space_optimized<value_type>::is_not_empty, this));
|
|
*pItem = m_container.back();
|
|
m_container.pop_back();
|
|
lock.unlock();
|
|
m_not_full.notify_one();
|
|
}
|
|
|
|
private:
|
|
|
|
bounded_buffer_space_optimized(const bounded_buffer_space_optimized&); // Disabled copy constructor
|
|
bounded_buffer_space_optimized& operator = (const bounded_buffer_space_optimized&); // Disabled assign operator
|
|
|
|
bool is_not_empty() const { return m_container.size() > 0; }
|
|
bool is_not_full() const { return m_container.size() < m_container.capacity(); }
|
|
|
|
container_type m_container;
|
|
boost::mutex m_mutex;
|
|
boost::condition m_not_empty;
|
|
boost::condition m_not_full;
|
|
};
|
|
|
|
template <class T>
|
|
class bounded_buffer_deque_based {
|
|
public:
|
|
|
|
typedef std::deque<T> container_type;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename boost::call_traits<value_type>::param_type param_type;
|
|
|
|
explicit bounded_buffer_deque_based(size_type capacity) : m_capacity(capacity) {}
|
|
|
|
void push_front(param_type item) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_full.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_full, this));
|
|
m_container.push_front(item);
|
|
lock.unlock();
|
|
m_not_empty.notify_one();
|
|
}
|
|
|
|
void pop_back(value_type* pItem) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_empty.wait(lock, boost::bind(&bounded_buffer_deque_based<value_type>::is_not_empty, this));
|
|
*pItem = m_container.back();
|
|
m_container.pop_back();
|
|
lock.unlock();
|
|
m_not_full.notify_one();
|
|
}
|
|
|
|
private:
|
|
|
|
bounded_buffer_deque_based(const bounded_buffer_deque_based&); // Disabled copy constructor
|
|
bounded_buffer_deque_based& operator = (const bounded_buffer_deque_based&); // Disabled assign operator
|
|
|
|
bool is_not_empty() const { return m_container.size() > 0; }
|
|
bool is_not_full() const { return m_container.size() < m_capacity; }
|
|
|
|
const size_type m_capacity;
|
|
container_type m_container;
|
|
boost::mutex m_mutex;
|
|
boost::condition m_not_empty;
|
|
boost::condition m_not_full;
|
|
};
|
|
|
|
template <class T>
|
|
class bounded_buffer_list_based {
|
|
public:
|
|
|
|
typedef std::list<T> container_type;
|
|
typedef typename container_type::size_type size_type;
|
|
typedef typename container_type::value_type value_type;
|
|
typedef typename boost::call_traits<value_type>::param_type param_type;
|
|
|
|
explicit bounded_buffer_list_based(size_type capacity) : m_capacity(capacity) {}
|
|
|
|
void push_front(param_type item) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_full.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_full, this));
|
|
m_container.push_front(item);
|
|
lock.unlock();
|
|
m_not_empty.notify_one();
|
|
}
|
|
|
|
void pop_back(value_type* pItem) {
|
|
boost::mutex::scoped_lock lock(m_mutex);
|
|
m_not_empty.wait(lock, boost::bind(&bounded_buffer_list_based<value_type>::is_not_empty, this));
|
|
*pItem = m_container.back();
|
|
m_container.pop_back();
|
|
lock.unlock();
|
|
m_not_full.notify_one();
|
|
}
|
|
|
|
private:
|
|
|
|
bounded_buffer_list_based(const bounded_buffer_list_based&); // Disabled copy constructor
|
|
bounded_buffer_list_based& operator = (const bounded_buffer_list_based&); // Disabled assign operator
|
|
|
|
bool is_not_empty() const { return m_container.size() > 0; }
|
|
bool is_not_full() const { return m_container.size() < m_capacity; }
|
|
|
|
const size_type m_capacity;
|
|
container_type m_container;
|
|
boost::mutex m_mutex;
|
|
boost::condition m_not_empty;
|
|
boost::condition m_not_full;
|
|
};
|
|
|
|
template<class Buffer>
|
|
class Consumer {
|
|
|
|
typedef typename Buffer::value_type value_type;
|
|
Buffer* m_container;
|
|
value_type m_item;
|
|
|
|
public:
|
|
Consumer(Buffer* buffer) : m_container(buffer) {}
|
|
|
|
void operator()() {
|
|
for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) {
|
|
m_container->pop_back(&m_item);
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class Buffer>
|
|
class Producer {
|
|
|
|
typedef typename Buffer::value_type value_type;
|
|
Buffer* m_container;
|
|
|
|
public:
|
|
Producer(Buffer* buffer) : m_container(buffer) {}
|
|
|
|
void operator()() {
|
|
for (unsigned long i = 0L; i < TOTAL_ELEMENTS; ++i) {
|
|
m_container->push_front(value_type());
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class Buffer>
|
|
void fifo_test(Buffer* buffer) {
|
|
|
|
// Start of measurement
|
|
boost::timer::auto_cpu_timer progress;
|
|
|
|
// Initialize the buffer with some values before launching producer and consumer threads.
|
|
for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {
|
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
|
|
buffer->push_front(Buffer::value_type());
|
|
#else
|
|
buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type());
|
|
#endif
|
|
}
|
|
|
|
Consumer<Buffer> consumer(buffer);
|
|
Producer<Buffer> producer(buffer);
|
|
|
|
// Start the threads.
|
|
boost::thread consume(consumer);
|
|
boost::thread produce(producer);
|
|
|
|
// Wait for completion.
|
|
consume.join();
|
|
produce.join();
|
|
|
|
// End of measurement
|
|
}
|
|
|
|
int main(int /*argc*/, char* /*argv*/[]) {
|
|
|
|
bounded_buffer<int> bb_int(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer<int> ";
|
|
fifo_test(&bb_int);
|
|
|
|
bounded_buffer_space_optimized<int> bb_space_optimized_int(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_space_optimized<int> ";
|
|
fifo_test(&bb_space_optimized_int);
|
|
|
|
bounded_buffer_deque_based<int> bb_deque_based_int(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_deque_based<int> ";
|
|
fifo_test(&bb_deque_based_int);
|
|
|
|
bounded_buffer_list_based<int> bb_list_based_int(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_list_based<int> ";
|
|
fifo_test(&bb_list_based_int);
|
|
|
|
bounded_buffer<std::string> bb_string(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer<std::string> ";
|
|
fifo_test(&bb_string);
|
|
|
|
bounded_buffer_space_optimized<std::string> bb_space_optimized_string(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_space_optimized<std::string> ";
|
|
fifo_test(&bb_space_optimized_string);
|
|
|
|
bounded_buffer_deque_based<std::string> bb_deque_based_string(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_deque_based<std::string> ";
|
|
fifo_test(&bb_deque_based_string);
|
|
|
|
bounded_buffer_list_based<std::string> bb_list_based_string(QUEUE_SIZE);
|
|
std::cout << "bounded_buffer_list_based<std::string> ";
|
|
fifo_test(&bb_list_based_string);
|
|
|
|
return 0;
|
|
}
|
|
/*
|
|
|
|
//[bounded_buffer_comparison_output
|
|
|
|
Description: Autorun "J:\Cpp\Misc\Debug\bounded_buffer_comparison.exe"
|
|
bounded_buffer<int> 5.15 s
|
|
|
|
bounded_buffer_space_optimized<int> 5.71 s
|
|
|
|
bounded_buffer_deque_based<int> 15.57 s
|
|
|
|
bounded_buffer_list_based<int> 17.33 s
|
|
|
|
bounded_buffer<std::string> 24.49 s
|
|
|
|
bounded_buffer_space_optimized<std::string> 28.33 s
|
|
|
|
bounded_buffer_deque_based<std::string> 29.45 s
|
|
|
|
bounded_buffer_list_based<std::string> 31.29 s
|
|
|
|
//] //[bounded_buffer_comparison_output]
|
|
|
|
*/
|