blob: 2139a97896df5650dec64102c104fea1025e8424 (
plain)
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
|
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// 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://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_ALLOCATOR_BUFFER_ALLOCATOR_HPP
#define BOOST_COMPUTE_ALLOCATOR_BUFFER_ALLOCATOR_HPP
#include <boost/compute/buffer.hpp>
#include <boost/compute/config.hpp>
#include <boost/compute/context.hpp>
#include <boost/compute/detail/device_ptr.hpp>
namespace boost {
namespace compute {
/// \class buffer_allocator
/// \brief The buffer_allocator class allocates memory with \ref buffer objects
///
/// \see buffer
template<class T>
class buffer_allocator
{
public:
typedef T value_type;
typedef detail::device_ptr<T> pointer;
typedef const detail::device_ptr<T> const_pointer;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
explicit buffer_allocator(const context &context)
: m_context(context),
m_mem_flags(buffer::read_write)
{
}
buffer_allocator(const buffer_allocator<T> &other)
: m_context(other.m_context),
m_mem_flags(other.m_mem_flags)
{
}
buffer_allocator<T>& operator=(const buffer_allocator<T> &other)
{
if(this != &other){
m_context = other.m_context;
m_mem_flags = other.m_mem_flags;
}
return *this;
}
#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
buffer_allocator(buffer_allocator<T>&& other) BOOST_NOEXCEPT
: m_context(std::move(other.m_context)),
m_mem_flags(other.m_mem_flags)
{
}
buffer_allocator<T>& operator=(buffer_allocator<T>&& other) BOOST_NOEXCEPT
{
m_context = std::move(other.m_context);
m_mem_flags = other.m_mem_flags;
return *this;
}
#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
~buffer_allocator()
{
}
pointer allocate(size_type n)
{
buffer buf(m_context, n * sizeof(T), m_mem_flags);
clRetainMemObject(buf.get());
return detail::device_ptr<T>(buf);
}
void deallocate(pointer p, size_type n)
{
BOOST_ASSERT(p.get_buffer().get_context() == m_context);
(void) n;
clReleaseMemObject(p.get_buffer().get());
}
size_type max_size() const
{
return m_context.get_device().max_memory_alloc_size() / sizeof(T);
}
context get_context() const
{
return m_context;
}
protected:
void set_mem_flags(cl_mem_flags flags)
{
m_mem_flags = flags;
}
private:
context m_context;
cl_mem_flags m_mem_flags;
};
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_ALLOCATOR_BUFFER_ALLOCATOR_HPP
|
