Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 1 | // |
| 2 | // Copyright 2012 Francisco Jerez |
| 3 | // |
| 4 | // Permission is hereby granted, free of charge, to any person obtaining a |
| 5 | // copy of this software and associated documentation files (the "Software"), |
| 6 | // to deal in the Software without restriction, including without limitation |
| 7 | // the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 | // and/or sell copies of the Software, and to permit persons to whom the |
| 9 | // Software is furnished to do so, subject to the following conditions: |
| 10 | // |
| 11 | // The above copyright notice and this permission notice shall be included in |
| 12 | // all copies or substantial portions of the Software. |
| 13 | // |
| 14 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 15 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 16 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
Kenneth Graunke | f0cb66b | 2013-04-21 13:52:08 -0700 | [diff] [blame] | 17 | // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 18 | // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 19 | // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 20 | // OTHER DEALINGS IN THE SOFTWARE. |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 21 | // |
| 22 | |
| 23 | #include "core/memory.hpp" |
| 24 | #include "core/resource.hpp" |
Eric Anholt | 882ca6d | 2019-06-27 15:05:31 -0700 | [diff] [blame] | 25 | #include "util/format/u_format.h" |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 26 | |
| 27 | using namespace clover; |
| 28 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 29 | memory_obj::memory_obj(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 30 | size_t size, void *host_ptr) : |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 31 | context(ctx), _flags(flags), |
Tom Stellard | c6d9801 | 2014-09-22 10:00:39 -0400 | [diff] [blame] | 32 | _size(size), _host_ptr(host_ptr) { |
Grigori Goronzy | f972b22 | 2015-05-19 09:28:30 +0200 | [diff] [blame] | 33 | if (flags & CL_MEM_COPY_HOST_PTR) |
Francisco Jerez | 60e7b08 | 2012-05-04 15:02:21 +0200 | [diff] [blame] | 34 | data.append((char *)host_ptr, size); |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 35 | } |
| 36 | |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 37 | memory_obj::~memory_obj() { |
Tom Stellard | c6d9801 | 2014-09-22 10:00:39 -0400 | [diff] [blame] | 38 | while (_destroy_notify.size()) { |
| 39 | _destroy_notify.top()(); |
| 40 | _destroy_notify.pop(); |
| 41 | } |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 42 | } |
| 43 | |
Francisco Jerez | 369419f | 2013-09-16 21:11:16 -0700 | [diff] [blame] | 44 | bool |
| 45 | memory_obj::operator==(const memory_obj &obj) const { |
| 46 | return this == &obj; |
| 47 | } |
| 48 | |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 49 | void |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 50 | memory_obj::destroy_notify(std::function<void ()> f) { |
Tom Stellard | c6d9801 | 2014-09-22 10:00:39 -0400 | [diff] [blame] | 51 | _destroy_notify.push(f); |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | cl_mem_flags |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 55 | memory_obj::flags() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 56 | return _flags; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | size_t |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 60 | memory_obj::size() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 61 | return _size; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | void * |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 65 | memory_obj::host_ptr() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 66 | return _host_ptr; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 67 | } |
| 68 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 69 | buffer::buffer(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 70 | size_t size, void *host_ptr) : |
| 71 | memory_obj(ctx, flags, size, host_ptr) { |
| 72 | } |
| 73 | |
| 74 | cl_mem_object_type |
| 75 | buffer::type() const { |
| 76 | return CL_MEM_OBJECT_BUFFER; |
| 77 | } |
| 78 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 79 | root_buffer::root_buffer(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 80 | size_t size, void *host_ptr) : |
| 81 | buffer(ctx, flags, size, host_ptr) { |
| 82 | } |
| 83 | |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 84 | resource & |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 85 | root_buffer::resource_in(command_queue &q) { |
| 86 | const void *data_ptr = NULL; |
| 87 | if (flags() & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)) |
| 88 | data_ptr = !data.empty() ? data.data() : host_ptr(); |
| 89 | |
| 90 | return resource(q, data_ptr); |
| 91 | } |
| 92 | |
| 93 | resource & |
| 94 | root_buffer::resource_undef(command_queue &q) { |
| 95 | return resource(q, NULL); |
| 96 | } |
| 97 | |
| 98 | resource & |
| 99 | root_buffer::resource(command_queue &q, const void *data_ptr) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 100 | // Create a new resource if there's none for this device yet. |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 101 | if (!resources.count(&q.device())) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 102 | auto r = (!resources.empty() ? |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 103 | new root_resource(q.device(), *this, |
| 104 | *resources.begin()->second) : |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 105 | new root_resource(q.device(), *this, q, data_ptr)); |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 106 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 107 | resources.insert(std::make_pair(&q.device(), |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 108 | std::unique_ptr<root_resource>(r))); |
| 109 | data.clear(); |
| 110 | } |
| 111 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 112 | return *resources.find(&q.device())->second; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 113 | } |
| 114 | |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 115 | void |
| 116 | root_buffer::resource_out(command_queue &q) { |
| 117 | resources.erase(&q.device()); |
| 118 | } |
| 119 | |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 120 | sub_buffer::sub_buffer(root_buffer &parent, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 121 | size_t offset, size_t size) : |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 122 | buffer(parent.context(), flags, size, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 123 | (char *)parent.host_ptr() + offset), |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 124 | parent(parent), _offset(offset) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 125 | } |
| 126 | |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 127 | resource & |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 128 | sub_buffer::resource_in(command_queue &q) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 129 | // Create a new resource if there's none for this device yet. |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 130 | if (!resources.count(&q.device())) { |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 131 | auto r = new sub_resource(parent().resource_in(q), {{ offset() }}); |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 132 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 133 | resources.insert(std::make_pair(&q.device(), |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 134 | std::unique_ptr<sub_resource>(r))); |
| 135 | } |
| 136 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 137 | return *resources.find(&q.device())->second; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 138 | } |
| 139 | |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 140 | resource & |
| 141 | sub_buffer::resource_undef(command_queue &q) { |
| 142 | return resource_in(q); |
| 143 | } |
| 144 | |
| 145 | void |
| 146 | sub_buffer::resource_out(command_queue &q) { |
| 147 | resources.erase(&q.device()); |
| 148 | } |
| 149 | |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 150 | size_t |
| 151 | sub_buffer::offset() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 152 | return _offset; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 153 | } |
| 154 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 155 | image::image(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 156 | const cl_image_format *format, |
| 157 | size_t width, size_t height, size_t depth, |
| 158 | size_t row_pitch, size_t slice_pitch, size_t size, |
| 159 | void *host_ptr) : |
| 160 | memory_obj(ctx, flags, size, host_ptr), |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 161 | _format(*format), _width(width), _height(height), _depth(depth), |
| 162 | _row_pitch(row_pitch), _slice_pitch(slice_pitch) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 163 | } |
| 164 | |
Francisco Jerez | d6f7afc | 2013-10-01 12:00:51 -0700 | [diff] [blame] | 165 | resource & |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 166 | image::resource_in(command_queue &q) { |
| 167 | const void *data_ptr = !data.empty() ? data.data() : NULL; |
| 168 | return resource(q, data_ptr); |
| 169 | } |
| 170 | |
| 171 | resource & |
| 172 | image::resource_undef(command_queue &q) { |
| 173 | return resource(q, NULL); |
| 174 | } |
| 175 | |
| 176 | resource & |
| 177 | image::resource(command_queue &q, const void *data_ptr) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 178 | // Create a new resource if there's none for this device yet. |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 179 | if (!resources.count(&q.device())) { |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 180 | auto r = (!resources.empty() ? |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 181 | new root_resource(q.device(), *this, |
| 182 | *resources.begin()->second) : |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 183 | new root_resource(q.device(), *this, q, data_ptr)); |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 184 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 185 | resources.insert(std::make_pair(&q.device(), |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 186 | std::unique_ptr<root_resource>(r))); |
| 187 | data.clear(); |
| 188 | } |
| 189 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 190 | return *resources.find(&q.device())->second; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 191 | } |
| 192 | |
Serge Martin | c0f03f6 | 2020-05-09 08:11:16 +0200 | [diff] [blame] | 193 | void |
| 194 | image::resource_out(command_queue &q) { |
| 195 | resources.erase(&q.device()); |
| 196 | } |
| 197 | |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 198 | cl_image_format |
| 199 | image::format() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 200 | return _format; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | size_t |
| 204 | image::width() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 205 | return _width; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | size_t |
| 209 | image::height() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 210 | return _height; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | size_t |
| 214 | image::depth() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 215 | return _depth; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | size_t |
Francisco Jerez | adefa84 | 2013-10-18 16:25:36 -0700 | [diff] [blame] | 219 | image::pixel_size() const { |
| 220 | return util_format_get_blocksize(translate_format(_format)); |
| 221 | } |
| 222 | |
| 223 | size_t |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 224 | image::row_pitch() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 225 | return _row_pitch; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | size_t |
| 229 | image::slice_pitch() const { |
Francisco Jerez | 8e14b82 | 2013-09-17 23:13:48 -0700 | [diff] [blame] | 230 | return _slice_pitch; |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 231 | } |
| 232 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 233 | image2d::image2d(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 234 | const cl_image_format *format, size_t width, |
| 235 | size_t height, size_t row_pitch, |
| 236 | void *host_ptr) : |
Zoltan Gilian | aa46fba | 2015-07-27 11:27:12 +0200 | [diff] [blame] | 237 | image(ctx, flags, format, width, height, 1, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 238 | row_pitch, 0, height * row_pitch, host_ptr) { |
| 239 | } |
| 240 | |
| 241 | cl_mem_object_type |
| 242 | image2d::type() const { |
| 243 | return CL_MEM_OBJECT_IMAGE2D; |
| 244 | } |
| 245 | |
Francisco Jerez | c4578d2 | 2014-02-18 15:07:11 +0100 | [diff] [blame] | 246 | image3d::image3d(clover::context &ctx, cl_mem_flags flags, |
Francisco Jerez | c6db1b3 | 2012-04-20 16:56:19 +0200 | [diff] [blame] | 247 | const cl_image_format *format, |
| 248 | size_t width, size_t height, size_t depth, |
| 249 | size_t row_pitch, size_t slice_pitch, |
| 250 | void *host_ptr) : |
| 251 | image(ctx, flags, format, width, height, depth, |
| 252 | row_pitch, slice_pitch, depth * slice_pitch, |
| 253 | host_ptr) { |
| 254 | } |
| 255 | |
| 256 | cl_mem_object_type |
| 257 | image3d::type() const { |
| 258 | return CL_MEM_OBJECT_IMAGE3D; |
| 259 | } |