codepad

Language:

#include <algorithm>

#include <exception>
#include <cstdlib>

#include <iostream>
#include <vector>

#include <memory>

#include <boost/shared_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/timer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/cstdint.hpp>

using namespace boost;
using namespace std;

struct obj
{
	char _c;
	long _v;
	wstring _str;
	char _data[104];
};

typedef std::shared_ptr<obj> std_obj_ptr;
typedef boost::shared_ptr<obj> boost_obj_ptr;

template <typename Pointer>
void thread_method(vector<Pointer> objects)
{
	// shuffling
	random_shuffle(objects.begin(), objects.end());

// now doing stuff that increases reference count
	vector<Pointer> transformed(objects.size());
	std::transform(objects.begin(), objects.end(), transformed.begin(),	[](Pointer in) -> Pointer
	{
		// increase ref count
		Pointer out = in;

// play around with data don't worry about race conditions
		// we don't care about the results
		out->_c = in->_c + 'c';
		out->_v = in->_v << 1;
		return out;
	}
	);

// now we drop the reference count
	transformed.clear();

}

template <typename Pointer, typename Delete>
boost::uint64_t work_with_stuff(size_t count, size_t threads, Delete del)
{
	if (!count || !threads)
		return 0;

timer t;

vector<Pointer> v(count);

// building all our little objects
	generate(v.begin(), v.end(), []{return Pointer(new obj()); });

thread_group run_group;

// let's thread !
	for(size_t i = 0; i < threads; ++i)
	{
		run_group.create_thread(boost::bind(thread_method<Pointer>, v));
	}

// wait for everything to end
	run_group.join_all();

// do the clean up
	for_each(v.begin(), v.end(), del);

// ref count => 0
	v.clear();

return static_cast<boost::uint64_t>(t.elapsed() * 1000.0);

}

int wmain(int argc, wchar_t **argv, wchar_t *)
{

try
	{

size_t objs[] =	{ 1000, 2500, 5000, 6000, 7000, 8000, 9000, 10000, 25000, 50000, 75000, 100000 };
		vector<size_t> threads(8);
		int i = 0;
		generate(threads.begin(), threads.end(), [&i] { return ++i; });

for_each(objs, objs + sizeof(objs) / sizeof(size_t),
			[&threads](int obj_count)
		{
			for_each(threads.begin(), threads.end(), [&obj_count](int thread_count)
			{
				// no need to clean up anything, smart pointers do that for us
				boost::uint64_t std_time = work_with_stuff<std_obj_ptr>(obj_count, thread_count, [](std_obj_ptr p) {});
				boost::uint64_t boost_time = work_with_stuff<boost_obj_ptr>(obj_count, thread_count, [](boost_obj_ptr p) {});

// we need to manually delete in this case
				boost::uint64_t raw_time = work_with_stuff<obj *>(obj_count, thread_count,  [](obj *p) { delete p; });

wchar_t separator = '\t';

wcout << obj_count << separator;
				wcout << thread_count << separator;
				wcout << std_time << separator;
				wcout << boost_time << separator;
				wcout << raw_time << separator;
				wcout << endl;
			});
		});

return 0;

}

catch(const std::exception & e)
	{
		cerr << "error: " << e.what() << endl;
		return -1;
	}

}

Private [?]

Run code