Spaces:
Runtime error
Runtime error
File size: 4,237 Bytes
be11144 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 |
#include <thrust/detail/config.h>
#if THRUST_CPP_DIALECT >= 2011
# include <unittest/unittest.h>
# include <thrust/allocate_unique.h>
# include <thrust/memory/detail/device_system_resource.h>
# include <thrust/mr/allocator.h>
# include <thrust/type_traits/is_contiguous_iterator.h>
# include <numeric>
# include <vector>
namespace
{
template <typename T>
using allocator =
thrust::mr::stateless_resource_allocator<T, thrust::universal_memory_resource>;
// The managed_memory_pointer class should be identified as a
// contiguous_iterator
THRUST_STATIC_ASSERT(
thrust::is_contiguous_iterator<allocator<int>::pointer>::value);
template <typename T>
struct some_object {
some_object(T data)
: m_data(data)
{}
void setter(T data) { m_data = data; }
T getter() const { return m_data; }
private:
T m_data;
};
} // namespace
template <typename T>
void TestAllocateUnique()
{
// Simple test to ensure that pointers created with universal_memory_resource
// can be dereferenced and used with STL code. This is necessary as some
// STL implementations break when using fancy references that overload
// `operator&`, so universal_memory_resource uses a special pointer type that
// returns regular C++ references that can be safely used host-side.
// These operations fail to compile with fancy references:
auto pRaw = thrust::allocate_unique<T>(allocator<T>{}, 42);
auto pObj =
thrust::allocate_unique<some_object<T> >(allocator<some_object<T> >{}, 42);
static_assert(
std::is_same<decltype(pRaw.get()),
thrust::system::cuda::detail::managed_memory_pointer<T> >::value,
"Unexpected pointer returned from unique_ptr::get.");
static_assert(
std::is_same<decltype(pObj.get()),
thrust::system::cuda::detail::managed_memory_pointer<
some_object<T> > >::value,
"Unexpected pointer returned from unique_ptr::get.");
ASSERT_EQUAL(*pRaw, T(42));
ASSERT_EQUAL(*pRaw.get(), T(42));
ASSERT_EQUAL(pObj->getter(), T(42));
ASSERT_EQUAL((*pObj).getter(), T(42));
ASSERT_EQUAL(pObj.get()->getter(), T(42));
ASSERT_EQUAL((*pObj.get()).getter(), T(42));
}
DECLARE_GENERIC_UNITTEST(TestAllocateUnique);
template <typename T>
void TestIterationRaw()
{
auto array = thrust::allocate_unique_n<T>(allocator<T>{}, 6, 42);
static_assert(
std::is_same<decltype(array.get()),
thrust::system::cuda::detail::managed_memory_pointer<T> >::value,
"Unexpected pointer returned from unique_ptr::get.");
for (auto iter = array.get(), end = array.get() + 6; iter < end; ++iter)
{
ASSERT_EQUAL(*iter, T(42));
ASSERT_EQUAL(*iter.get(), T(42));
}
}
DECLARE_GENERIC_UNITTEST(TestIterationRaw);
template <typename T>
void TestIterationObj()
{
auto array =
thrust::allocate_unique_n<some_object<T> >(allocator<some_object<T> >{},
6,
42);
static_assert(
std::is_same<decltype(array.get()),
thrust::system::cuda::detail::managed_memory_pointer<
some_object<T> > >::value,
"Unexpected pointer returned from unique_ptr::get.");
for (auto iter = array.get(), end = array.get() + 6; iter < end; ++iter)
{
ASSERT_EQUAL(iter->getter(), T(42));
ASSERT_EQUAL((*iter).getter(), T(42));
ASSERT_EQUAL(iter.get()->getter(), T(42));
ASSERT_EQUAL((*iter.get()).getter(), T(42));
}
}
DECLARE_GENERIC_UNITTEST(TestIterationObj);
template <typename T>
void TestStdVector()
{
// Verify that a std::vector using the universal allocator will work with
// STL algorithms.
std::vector<T, allocator<T> > v0;
static_assert(
std::is_same<typename std::decay<decltype(v0)>::type::pointer,
thrust::system::cuda::detail::managed_memory_pointer<
T > >::value,
"Unexpected pointer returned from unique_ptr::get.");
v0.resize(6);
std::iota(v0.begin(), v0.end(), 0);
ASSERT_EQUAL(v0[0], T(0));
ASSERT_EQUAL(v0[1], T(1));
ASSERT_EQUAL(v0[2], T(2));
ASSERT_EQUAL(v0[3], T(3));
ASSERT_EQUAL(v0[4], T(4));
ASSERT_EQUAL(v0[5], T(5));
}
DECLARE_GENERIC_UNITTEST(TestStdVector);
#endif // C++11
|