libs/type_traits/examples/trivial_destructor_example.cpp
/*
*
* (C) Copyright John Maddock 1999-2005.
* Use, modification and distribution are 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)
*
* This file provides some example of type_traits usage -
* by "optimising" various algorithms:
*
* opt::destroy_array - an example of optimisation based upon omitted destructor calls
*
*/
#include <iostream>
#include <boost/test/included/prg_exec_monitor.hpp>
#include <boost/timer.hpp>
#include <boost/type_traits.hpp>
using std::cout;
using std::endl;
using std::cin;
namespace opt{
//
// algorithm destroy_array:
// The reverse of std::unitialized_copy, takes a block of
// initialized memory and calls destructors on all objects therein.
//
namespace detail{
template <class T>
void do_destroy_array(T* first, T* last, const boost::false_type&)
{
while(first != last)
{
first->~T();
++first;
}
}
template <class T>
inline void do_destroy_array(T* first, T* last, const boost::true_type&)
{
}
} // namespace detail
template <class T>
inline void destroy_array(T* p1, T* p2)
{
detail::do_destroy_array(p1, p2, ::boost::has_trivial_destructor<T>());
}
//
// unoptimised versions of destroy_array:
//
template <class T>
void destroy_array1(T* first, T* last)
{
while(first != last)
{
first->~T();
++first;
}
}
template <class T>
void destroy_array2(T* first, T* last)
{
for(; first != last; ++first) first->~T();
}
} // namespace opt
//
// define some global data:
//
const int array_size = 1000;
int i_array[array_size] = {0,};
const int ci_array[array_size] = {0,};
char c_array[array_size] = {0,};
const char cc_array[array_size] = { 0,};
const int iter_count = 1000000;
int cpp_main(int argc, char* argv[])
{
boost::timer t;
double result;
int i;
//
// test destroy_array,
// compare destruction time of an array of ints
// with unoptimised form.
//
cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
cout << "testing destroy_array...\n"
"[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
// cache load:
opt::destroy_array(i_array, i_array + array_size);
// time optimised version:
t.restart();
for(i = 0; i < iter_count; ++i)
{
opt::destroy_array(i_array, i_array + array_size);
}
result = t.elapsed();
cout << "destroy_array<int>: " << result << endl;
// cache load:
opt::destroy_array1(i_array, i_array + array_size);
// time unoptimised version #1:
t.restart();
for(i = 0; i < iter_count; ++i)
{
opt::destroy_array1(i_array, i_array + array_size);
}
result = t.elapsed();
cout << "destroy_array<int>(unoptimised#1): " << result << endl;
// cache load:
opt::destroy_array2(i_array, i_array + array_size);
// time unoptimised version #2:
t.restart();
for(i = 0; i < iter_count; ++i)
{
opt::destroy_array2(i_array, i_array + array_size);
}
result = t.elapsed();
cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
return 0;
}