diff options
Diffstat (limited to 'src/boost/libs/interprocess/test/offset_ptr_test.cpp')
| -rw-r--r-- | src/boost/libs/interprocess/test/offset_ptr_test.cpp | 352 |
1 files changed, 352 insertions, 0 deletions
diff --git a/src/boost/libs/interprocess/test/offset_ptr_test.cpp b/src/boost/libs/interprocess/test/offset_ptr_test.cpp new file mode 100644 index 00000000..bece39b0 --- /dev/null +++ b/src/boost/libs/interprocess/test/offset_ptr_test.cpp @@ -0,0 +1,352 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2007-2012. 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) +// +// See http://www.boost.org/libs/interprocess for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#include <boost/interprocess/detail/config_begin.hpp> +#include <boost/interprocess/offset_ptr.hpp> +#include <boost/interprocess/detail/type_traits.hpp> +#include <boost/intrusive/pointer_traits.hpp> +#include <boost/static_assert.hpp> +#include <boost/core/lightweight_test.hpp> + +using namespace boost::interprocess; + +class Base +{}; + +class Derived + : public Base +{}; + +class VirtualDerived + : public virtual Base +{}; + +void test_types_and_conversions() +{ + typedef offset_ptr<int> pint_t; + typedef offset_ptr<const int> pcint_t; + typedef offset_ptr<volatile int> pvint_t; + typedef offset_ptr<const volatile int> pcvint_t; + + BOOST_STATIC_ASSERT((ipcdetail::is_same<pint_t::element_type, int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pcint_t::element_type, const int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pvint_t::element_type, volatile int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pcvint_t::element_type, const volatile int>::value)); + + BOOST_STATIC_ASSERT((ipcdetail::is_same<pint_t::value_type, int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pcint_t::value_type, int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pvint_t::value_type, int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<pcvint_t::value_type, int>::value)); + int dummy_int = 9; + + { pint_t pint(&dummy_int); + pcint_t pcint(pint); + BOOST_TEST(pcint.get() == &dummy_int); + } + { pint_t pint(&dummy_int); + pvint_t pvint(pint); + BOOST_TEST(pvint.get() == &dummy_int); + } + { pint_t pint(&dummy_int); + pcvint_t pcvint(pint); + BOOST_TEST(pcvint.get() == &dummy_int); + } + { pcint_t pcint(&dummy_int); + pcvint_t pcvint(pcint); + BOOST_TEST(pcvint.get() == &dummy_int); + } + { pvint_t pvint(&dummy_int); + pcvint_t pcvint(pvint); + BOOST_TEST(pcvint.get() == &dummy_int); + } + + pint_t pint(0); + pcint_t pcint(0); + pvint_t pvint(0); + pcvint_t pcvint(0); + + pint = &dummy_int; + pcint = &dummy_int; + pvint = &dummy_int; + pcvint = &dummy_int; + + { pcint = pint; + BOOST_TEST(pcint.get() == &dummy_int); + } + { pvint = pint; + BOOST_TEST(pvint.get() == &dummy_int); + } + { pcvint = pint; + BOOST_TEST(pcvint.get() == &dummy_int); + } + { pcvint = pcint; + BOOST_TEST(pcvint.get() == &dummy_int); + } + { pcvint = pvint; + BOOST_TEST(pcvint.get() == &dummy_int); + } + + BOOST_TEST(pint); + + pint = 0; + BOOST_TEST(!pint); + + BOOST_TEST(pint == 0); + + BOOST_TEST(0 == pint); + + pint = &dummy_int; + BOOST_TEST(0 != pint); + + pcint = &dummy_int; + + BOOST_TEST( (pcint - pint) == 0); + BOOST_TEST( (pint - pcint) == 0); +} + +template<class BasePtr, class DerivedPtr> +void test_base_derived_impl() +{ + typename DerivedPtr::element_type d; + DerivedPtr pderi(&d); + + BasePtr pbase(pderi); + pbase = pderi; + BOOST_TEST(pbase == pderi); + BOOST_TEST(!(pbase != pderi)); + BOOST_TEST((pbase - pderi) == 0); + BOOST_TEST(!(pbase < pderi)); + BOOST_TEST(!(pbase > pderi)); + BOOST_TEST(pbase <= pderi); + BOOST_TEST((pbase >= pderi)); +} + +void test_base_derived() +{ + typedef offset_ptr<Base> pbase_t; + typedef offset_ptr<const Base> pcbas_t; + typedef offset_ptr<Derived> pderi_t; + typedef offset_ptr<VirtualDerived> pvder_t; + + test_base_derived_impl<pbase_t, pderi_t>(); + test_base_derived_impl<pbase_t, pvder_t>(); + test_base_derived_impl<pcbas_t, pderi_t>(); + test_base_derived_impl<pcbas_t, pvder_t>(); +} + +void test_arithmetic() +{ + typedef offset_ptr<int> pint_t; + const int NumValues = 5; + int values[NumValues]; + + //Initialize p + pint_t p = values; + BOOST_TEST(p.get() == values); + + //Initialize p + NumValues + pint_t pe = &values[NumValues]; + BOOST_TEST(pe != p); + BOOST_TEST(pe.get() == &values[NumValues]); + + //ptr - ptr + BOOST_TEST((pe - p) == NumValues); + + //ptr - integer + BOOST_TEST((pe - NumValues) == p); + + //ptr + integer + BOOST_TEST((p + NumValues) == pe); + + //integer + ptr + BOOST_TEST((NumValues + p) == pe); + + //indexing + BOOST_TEST(pint_t(&p[NumValues]) == pe); + BOOST_TEST(pint_t(&pe[-NumValues]) == p); + + //ptr -= integer + pint_t p0 = pe; + p0-= NumValues; + BOOST_TEST(p == p0); + + //ptr += integer + pint_t penew = p0; + penew += NumValues; + BOOST_TEST(penew == pe); + + //++ptr + penew = p0; + for(int j = 0; j != NumValues; ++j, ++penew); + BOOST_TEST(penew == pe); + + //--ptr + p0 = pe; + for(int j = 0; j != NumValues; ++j, --p0); + BOOST_TEST(p == p0); + + //ptr++ + penew = p0; + for(int j = 0; j != NumValues; ++j){ + pint_t p_new_copy = penew; + BOOST_TEST(p_new_copy == penew++); + } + //ptr-- + p0 = pe; + for(int j = 0; j != NumValues; ++j){ + pint_t p0_copy = p0; + BOOST_TEST(p0_copy == p0--); + } +} + +void test_comparison() +{ + typedef offset_ptr<int> pint_t; + const int NumValues = 5; + int values[NumValues]; + + //Initialize p + pint_t p = values; + BOOST_TEST(p.get() == values); + + //Initialize p + NumValues + pint_t pe = &values[NumValues]; + BOOST_TEST(pe != p); + + BOOST_TEST(pe.get() == &values[NumValues]); + + //operators + BOOST_TEST(p != pe); + BOOST_TEST(p == p); + BOOST_TEST((p < pe)); + BOOST_TEST((p <= pe)); + BOOST_TEST((pe > p)); + BOOST_TEST((pe >= p)); +} + +bool test_pointer_traits() +{ + typedef offset_ptr<int> OInt; + typedef boost::intrusive::pointer_traits< OInt > PTOInt; + BOOST_STATIC_ASSERT((ipcdetail::is_same<PTOInt::element_type, int>::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<PTOInt::pointer, OInt >::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<PTOInt::difference_type, OInt::difference_type >::value)); + BOOST_STATIC_ASSERT((ipcdetail::is_same<PTOInt::rebind_pointer<double>::type, offset_ptr<double> >::value)); + int dummy; + OInt oi(&dummy); + if(boost::intrusive::pointer_traits<OInt>::pointer_to(dummy) != oi){ + return false; + } + return true; +} + +struct node +{ + offset_ptr<node> next; +}; + +void test_pointer_plus_bits() +{ + BOOST_STATIC_ASSERT((boost::intrusive::max_pointer_plus_bits< offset_ptr<void>, boost::move_detail::alignment_of<node>::value >::value >= 1U)); + typedef boost::intrusive::pointer_plus_bits< offset_ptr<node>, 1u > ptr_plus_bits; + + node n, n2; + offset_ptr<node> pnode(&n); + + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) == &n); + BOOST_TEST(0 == ptr_plus_bits::get_bits(pnode)); + ptr_plus_bits::set_bits(pnode, 1u); + BOOST_TEST(1 == ptr_plus_bits::get_bits(pnode)); + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) == &n); + + ptr_plus_bits::set_pointer(pnode, &n2); + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) == &n2); + BOOST_TEST(1 == ptr_plus_bits::get_bits(pnode)); + ptr_plus_bits::set_bits(pnode, 0u); + BOOST_TEST(0 == ptr_plus_bits::get_bits(pnode)); + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) == &n2); + + ptr_plus_bits::set_pointer(pnode, offset_ptr<node>()); + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) ==0); + BOOST_TEST(0 == ptr_plus_bits::get_bits(pnode)); + ptr_plus_bits::set_bits(pnode, 1u); + BOOST_TEST(1 == ptr_plus_bits::get_bits(pnode)); + BOOST_TEST(ptr_plus_bits::get_pointer(pnode) == 0); +} + +int main() +{ + test_types_and_conversions(); + test_base_derived(); + test_arithmetic(); + test_comparison(); + test_pointer_traits(); + test_pointer_plus_bits(); + return ::boost::report_errors(); +} + +#include <boost/interprocess/detail/config_end.hpp> + +/* +//Offset ptr benchmark +#include <vector> +#include <iostream> +#include <boost/interprocess/managed_shared_memory.hpp> +#include <boost/interprocess/containers/vector.hpp> +#include <boost/interprocess/allocators/allocator.hpp> +#include <boost/timer.hpp> +#include <cstddef> + +template<class InIt, + class Ty> inline + Ty accumulate2(InIt First, InIt Last, Ty Val) + { // return sum of Val and all in [First, Last) + for (; First != Last; ++First) //First = First + 1) + Val = Val + *First; + return (Val); + } + +template <typename Vector> +void time_test(const Vector& vec, std::size_t iterations, const char* label) { + // assert(!vec.empty()) + boost::timer t; + typename Vector::const_iterator first = vec.begin(); + typename Vector::value_type result(0); + while (iterations != 0) { + result = accumulate2(first, first + vec.size(), result); + --iterations; + } + std::cout << label << t.elapsed() << " " << result << std::endl; +} + +int main() +{ + using namespace boost::interprocess; + typedef allocator<double, managed_shared_memory::segment_manager> alloc_t; + + std::size_t n = 0x1 << 26; + std::size_t file_size = n * sizeof(double) + 1000000; + + { + shared_memory_object::remove("MyMappedFile"); + managed_shared_memory segment(open_or_create, "MyMappedFile", file_size); + shared_memory_object::remove("MyMappedFile"); + alloc_t alloc_inst(segment.get_segment_manager()); + vector<double, alloc_t> v0(n, double(42.42), alloc_inst); + time_test(v0, 10, "iterator shared: "); + } + { + std::vector<double> v1(n, double(42.42)); + time_test(v1, 10, "iterator non-shared: "); + } + return 0; +} + +*/ |