fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-24 17:30:12 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

clover: Switch memory objects to the new model.

Browse source 
Tested-by: Tom Stellard <thomas.stellard@amd.com>
This commit is contained in:
Francisco Jerez 2013-10-01 12:00:51 -07:00
parent 35307f540f
commit d6f7afc3ed
9 changed files with 274 additions and 309 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
src/gallium/state_trackers/clover/api/memory.cpp
View file

@ -27,10 +27,9 @@
using namespace clover;
PUBLIC cl_mem
clCreateBuffer(cl_context ctx, cl_mem_flags flags, size_t size,
void *host_ptr, cl_int *errcode_ret) try {
if (!ctx)
throw error(CL_INVALID_CONTEXT);
clCreateBuffer(cl_context d_ctx, cl_mem_flags flags, size_t size,
void *host_ptr, cl_int *r_errcode) try {
auto &ctx = obj(d_ctx);
if (bool(host_ptr) != bool(flags & (CL_MEM_USE_HOST_PTR |
CL_MEM_COPY_HOST_PTR)))
@ -44,49 +43,47 @@ clCreateBuffer(cl_context ctx, cl_mem_flags flags, size_t size,
CL_MEM_COPY_HOST_PTR))
throw error(CL_INVALID_VALUE);
ret_error(errcode_ret, CL_SUCCESS);
return new root_buffer(obj(ctx), flags, size, host_ptr);
ret_error(r_errcode, CL_SUCCESS);
return new root_buffer(ctx, flags, size, host_ptr);
} catch (error &e) {
ret_error(errcode_ret, e);
ret_error(r_errcode, e);
return NULL;
}
PUBLIC cl_mem
clCreateSubBuffer(cl_mem obj, cl_mem_flags flags, cl_buffer_create_type op,
const void *op_info, cl_int *errcode_ret) try {
root_buffer *parent = dynamic_cast<root_buffer *>(obj);
if (!parent)
throw error(CL_INVALID_MEM_OBJECT);
clCreateSubBuffer(cl_mem d_mem, cl_mem_flags flags,
cl_buffer_create_type op,
const void *op_info, cl_int *r_errcode) try {
auto &parent = obj<root_buffer>(d_mem);
if ((flags & (CL_MEM_USE_HOST_PTR |
CL_MEM_ALLOC_HOST_PTR |
CL_MEM_COPY_HOST_PTR)) ||
(~flags & parent->flags() & (CL_MEM_READ_ONLY |
CL_MEM_WRITE_ONLY)))
(~flags & parent.flags() & (CL_MEM_READ_ONLY |
CL_MEM_WRITE_ONLY)))
throw error(CL_INVALID_VALUE);
if (op == CL_BUFFER_CREATE_TYPE_REGION) {
const cl_buffer_region *reg = (const cl_buffer_region *)op_info;
auto reg = reinterpret_cast<const cl_buffer_region *>(op_info);
if (!reg ||
reg->origin > parent->size() ||
reg->origin + reg->size > parent->size())
reg->origin > parent.size() ||
reg->origin + reg->size > parent.size())
throw error(CL_INVALID_VALUE);
if (!reg->size)
throw error(CL_INVALID_BUFFER_SIZE);
ret_error(errcode_ret, CL_SUCCESS);
return new sub_buffer(*parent, flags, reg->origin, reg->size);
ret_error(r_errcode, CL_SUCCESS);
return new sub_buffer(parent, flags, reg->origin, reg->size);
} else {
throw error(CL_INVALID_VALUE);
}
} catch (error &e) {
ret_error(errcode_ret, e);
ret_error(r_errcode, e);
return NULL;
}
@ -94,7 +91,7 @@ PUBLIC cl_mem
clCreateImage2D(cl_context d_ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t row_pitch,
void *host_ptr, cl_int *errcode_ret) try {
void *host_ptr, cl_int *r_errcode) try {
auto &ctx = obj(d_ctx);
if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
@ -115,12 +112,12 @@ clCreateImage2D(cl_context d_ctx, cl_mem_flags flags,
if (!supported_formats(ctx, CL_MEM_OBJECT_IMAGE2D).count(*format))
throw error(CL_IMAGE_FORMAT_NOT_SUPPORTED);
ret_error(errcode_ret, CL_SUCCESS);
ret_error(r_errcode, CL_SUCCESS);
return new image2d(ctx, flags, format, width, height,
row_pitch, host_ptr);
} catch (error &e) {
ret_error(errcode_ret, e);
ret_error(r_errcode, e);
return NULL;
}
@ -129,7 +126,7 @@ clCreateImage3D(cl_context d_ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
size_t row_pitch, size_t slice_pitch,
void *host_ptr, cl_int *errcode_ret) try {
void *host_ptr, cl_int *r_errcode) try {
auto &ctx = obj(d_ctx);
if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
@ -150,19 +147,19 @@ clCreateImage3D(cl_context d_ctx, cl_mem_flags flags,
if (!supported_formats(ctx, CL_MEM_OBJECT_IMAGE3D).count(*format))
throw error(CL_IMAGE_FORMAT_NOT_SUPPORTED);
ret_error(errcode_ret, CL_SUCCESS);
ret_error(r_errcode, CL_SUCCESS);
return new image3d(ctx, flags, format, width, height, depth,
row_pitch, slice_pitch, host_ptr);
} catch (error &e) {
ret_error(errcode_ret, e);
ret_error(r_errcode, e);
return NULL;
}
PUBLIC cl_int
clGetSupportedImageFormats(cl_context d_ctx, cl_mem_flags flags,
cl_mem_object_type type, cl_uint count,
cl_image_format *buf, cl_uint *count_ret) try {
cl_image_format *r_buf, cl_uint *r_count) try {
auto &ctx = obj(d_ctx);
if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
@ -170,16 +167,18 @@ clGetSupportedImageFormats(cl_context d_ctx, cl_mem_flags flags,
CL_MEM_COPY_HOST_PTR))
throw error(CL_INVALID_VALUE);
if (!count && buf)
if (r_buf && !r_count)
throw error(CL_INVALID_VALUE);
auto formats = supported_formats(ctx, type);
if (buf)
std::copy_n(formats.begin(), std::min((cl_uint)formats.size(), count),
buf);
if (count_ret)
*count_ret = formats.size();
if (r_buf)
std::copy_n(formats.begin(),
std::min((cl_uint)formats.size(), count),
r_buf);
if (r_count)
*r_count = formats.size();
return CL_SUCCESS;
@ -188,28 +187,26 @@ clGetSupportedImageFormats(cl_context d_ctx, cl_mem_flags flags,
}
PUBLIC cl_int
clGetMemObjectInfo(cl_mem obj, cl_mem_info param,
clGetMemObjectInfo(cl_mem d_mem, cl_mem_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
if (!obj)
return CL_INVALID_MEM_OBJECT;
auto &mem = obj(d_mem);
switch (param) {
case CL_MEM_TYPE:
buf.as_scalar<cl_mem_object_type>() = obj->type();
buf.as_scalar<cl_mem_object_type>() = mem.type();
break;
case CL_MEM_FLAGS:
buf.as_scalar<cl_mem_flags>() = obj->flags();
buf.as_scalar<cl_mem_flags>() = mem.flags();
break;
case CL_MEM_SIZE:
buf.as_scalar<size_t>() = obj->size();
buf.as_scalar<size_t>() = mem.size();
break;
case CL_MEM_HOST_PTR:
buf.as_scalar<void *>() = obj->host_ptr();
buf.as_scalar<void *>() = mem.host_ptr();
break;
case CL_MEM_MAP_COUNT:
@ -217,20 +214,20 @@ clGetMemObjectInfo(cl_mem obj, cl_mem_info param,
break;
case CL_MEM_REFERENCE_COUNT:
buf.as_scalar<cl_uint>() = obj->ref_count();
buf.as_scalar<cl_uint>() = mem.ref_count();
break;
case CL_MEM_CONTEXT:
buf.as_scalar<cl_context>() = &obj->ctx;
buf.as_scalar<cl_context>() = desc(mem.ctx);
break;
case CL_MEM_ASSOCIATED_MEMOBJECT: {
sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
buf.as_scalar<cl_mem>() = (sub ? &sub->parent : NULL);
sub_buffer *sub = dynamic_cast<sub_buffer *>(&mem);
buf.as_scalar<cl_mem>() = (sub ? desc(sub->parent) : NULL);
break;
}
case CL_MEM_OFFSET: {
sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
sub_buffer *sub = dynamic_cast<sub_buffer *>(&mem);
buf.as_scalar<size_t>() = (sub ? sub->offset() : 0);
break;
}
@ -245,17 +242,14 @@ clGetMemObjectInfo(cl_mem obj, cl_mem_info param,
}
PUBLIC cl_int
clGetImageInfo(cl_mem obj, cl_image_info param,
clGetImageInfo(cl_mem d_mem, cl_image_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
image *img = dynamic_cast<image *>(obj);
if (!img)
return CL_INVALID_MEM_OBJECT;
auto &img = obj<image>(d_mem);
switch (param) {
case CL_IMAGE_FORMAT:
buf.as_scalar<cl_image_format>() = img->format();
buf.as_scalar<cl_image_format>() = img.format();
break;
case CL_IMAGE_ELEMENT_SIZE:
@ -263,23 +257,23 @@ clGetImageInfo(cl_mem obj, cl_image_info param,
break;
case CL_IMAGE_ROW_PITCH:
buf.as_scalar<size_t>() = img->row_pitch();
buf.as_scalar<size_t>() = img.row_pitch();
break;
case CL_IMAGE_SLICE_PITCH:
buf.as_scalar<size_t>() = img->slice_pitch();
buf.as_scalar<size_t>() = img.slice_pitch();
break;
case CL_IMAGE_WIDTH:
buf.as_scalar<size_t>() = img->width();
buf.as_scalar<size_t>() = img.width();
break;
case CL_IMAGE_HEIGHT:
buf.as_scalar<size_t>() = img->height();
buf.as_scalar<size_t>() = img.height();
break;
case CL_IMAGE_DEPTH:
buf.as_scalar<size_t>() = img->depth();
buf.as_scalar<size_t>() = img.depth();
break;
default:
@ -293,36 +287,38 @@ clGetImageInfo(cl_mem obj, cl_image_info param,
}
PUBLIC cl_int
clRetainMemObject(cl_mem obj) {
if (!obj)
return CL_INVALID_MEM_OBJECT;
obj->retain();
clRetainMemObject(cl_mem d_mem) try {
obj(d_mem).retain();
return CL_SUCCESS;
} catch (error &e) {
return e.get();
}
PUBLIC cl_int
clReleaseMemObject(cl_mem obj) {
if (!obj)
return CL_INVALID_MEM_OBJECT;
if (obj->release())
delete obj;
clReleaseMemObject(cl_mem d_mem) try {
if (obj(d_mem).release())
delete pobj(d_mem);
return CL_SUCCESS;
} catch (error &e) {
return e.get();
}
PUBLIC cl_int
clSetMemObjectDestructorCallback(cl_mem obj,
clSetMemObjectDestructorCallback(cl_mem d_mem,
void (CL_CALLBACK *pfn_notify)(cl_mem, void *),
void *user_data) {
if (!obj)
return CL_INVALID_MEM_OBJECT;
void *user_data) try {
auto &mem = obj(d_mem);
if (!pfn_notify)
return CL_INVALID_VALUE;
obj->destroy_notify([=]{ pfn_notify(obj, user_data); });
mem.destroy_notify([=]{ pfn_notify(d_mem, user_data); });
return CL_SUCCESS;
} catch (error &e) {
return e.get();
}

234
src/gallium/state_trackers/clover/api/transfer.cpp
View file

@ -40,27 +40,17 @@ namespace {
/// Common argument checking shared by memory transfer commands.
///
void
validate_base(command_queue &q, cl_uint num_deps, const cl_event *deps) {
if (bool(num_deps) != bool(deps) ||
any_of(is_zero(), range(deps, num_deps)))
throw error(CL_INVALID_EVENT_WAIT_LIST);
if (any_of([&](const cl_event ev) {
return &obj(ev).ctx != &q.ctx;
}, range(deps, num_deps)))
validate_common(command_queue &q,
std::initializer_list<std::reference_wrapper<memory_obj>> mems,
const ref_vector<event> &deps) {
if (any_of([&](const event &ev) {
return &ev.ctx != &q.ctx;
}, deps))
throw error(CL_INVALID_CONTEXT);
}
///
/// Memory object-specific argument checking shared by most memory
/// transfer commands.
///
void
validate_obj(command_queue &q, cl_mem mem) {
if (!mem)
throw error(CL_INVALID_MEM_OBJECT);
if (&mem->ctx != &q.ctx)
if (any_of([&](const memory_obj &mem) {
return &mem.ctx != &q.ctx;
}, mems))
throw error(CL_INVALID_CONTEXT);
}
@ -69,44 +59,45 @@ namespace {
/// \a T. The return value of get() should be implicitly
/// convertible to \a void *.
///
template<typename T> struct _map;
template<typename T>
struct _map {
static mapping
get(command_queue &q, T obj, cl_map_flags flags,
size_t offset, size_t size) {
return { q, obj->resource(q), flags, true,
{{ offset }}, {{ size, 1, 1 }} };
}
};
template<> struct _map<void *> {
template<>
struct _map<void *> {
static void *
get(cl_command_queue q, void *obj, cl_map_flags flags,
get(command_queue &q, void *obj, cl_map_flags flags,
size_t offset, size_t size) {
return (char *)obj + offset;
}
};
template<> struct _map<const void *> {
template<>
struct _map<const void *> {
static const void *
get(cl_command_queue q, const void *obj, cl_map_flags flags,
get(command_queue &q, const void *obj, cl_map_flags flags,
size_t offset, size_t size) {
return (const char *)obj + offset;
}
};
template<> struct _map<memory_obj *> {
static mapping
get(cl_command_queue q, memory_obj *mem, cl_map_flags flags,
size_t offset, size_t size) {<
return { obj(q), mem->resource(obj(q)), flags, true,
{{ offset }}, {{ size, 1, 1 }}};
}
};
///
/// Software copy from \a src_obj to \a dst_obj. They can be
/// either pointers or memory objects.
///
template<typename T, typename S>
std::function<void (event &)>
soft_copy_op(cl_command_queue q,
soft_copy_op(command_queue &q,
T dst_obj, const vector_t &dst_orig, const vector_t &dst_pitch,
S src_obj, const vector_t &src_orig, const vector_t &src_pitch,
const vector_t &region) {
return [=](event &) {
return [=, &q](event &) {
auto dst = _map<T>::get(q, dst_obj, CL_MAP_WRITE,
dot(dst_pitch, dst_orig),
dst_pitch[2] * region[2]);
@ -141,24 +132,24 @@ namespace {
}
PUBLIC cl_int
clEnqueueReadBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueReadBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
size_t offset, size_t size, void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
if (!ptr || offset > mem->size() || offset + size > mem->size())
if (!ptr || offset > mem.size() || offset + size > mem.size())
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_READ_BUFFER, deps,
soft_copy_op(d_q,
soft_copy_op(q,
ptr, {{ 0 }}, {{ 1 }},
mem, {{ offset }}, {{ 1 }},
&mem, {{ offset }}, {{ 1 }},
{{ size, 1, 1 }}));
ret_object(rd_ev, hev);
@ -169,23 +160,23 @@ clEnqueueReadBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
size_t offset, size_t size, const void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
if (!ptr || offset > mem->size() || offset + size > mem->size())
if (!ptr || offset > mem.size() || offset + size > mem.size())
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_WRITE_BUFFER, deps,
soft_copy_op(d_q,
mem, {{ offset }}, {{ 1 }},
soft_copy_op(q,
&mem, {{ offset }}, {{ 1 }},
ptr, {{ 0 }}, {{ 1 }},
{{ size, 1, 1 }}));
@ -197,7 +188,7 @@ clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *obj_origin,
const size_t *host_origin,
const size_t *region,
@ -207,20 +198,20 @@ clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
if (!ptr)
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_READ_BUFFER_RECT, deps,
soft_copy_op(d_q,
soft_copy_op(q,
ptr, vector(host_origin),
{{ 1, host_row_pitch, host_slice_pitch }},
mem, vector(obj_origin),
&mem, vector(obj_origin),
{{ 1, obj_row_pitch, obj_slice_pitch }},
vector(region)));
@ -232,7 +223,7 @@ clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *obj_origin,
const size_t *host_origin,
const size_t *region,
@ -242,18 +233,18 @@ clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
if (!ptr)
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_WRITE_BUFFER_RECT, deps,
soft_copy_op(d_q,
mem, vector(obj_origin),
soft_copy_op(q,
&mem, vector(obj_origin),
{{ 1, obj_row_pitch, obj_slice_pitch }},
ptr, vector(host_origin),
{{ 1, host_row_pitch, host_slice_pitch }},
@ -267,21 +258,21 @@ clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem src_mem, cl_mem dst_mem,
clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
size_t src_offset, size_t dst_offset, size_t size,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &src_mem = obj(d_src_mem);
auto &dst_mem = obj(d_dst_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, src_mem);
validate_obj(q, dst_mem);
validate_common(q, { src_mem, dst_mem }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_COPY_BUFFER, deps,
hard_copy_op(q, dst_mem, {{ dst_offset }},
src_mem, {{ src_offset }},
hard_copy_op(q, &dst_mem, {{ dst_offset }},
&src_mem, {{ src_offset }},
{{ size, 1, 1 }}));
ret_object(rd_ev, hev);
@ -292,8 +283,8 @@ clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem src_mem, cl_mem dst_mem,
}
PUBLIC cl_int
clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem src_mem,
cl_mem dst_mem,
clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem d_src_mem,
cl_mem d_dst_mem,
const size_t *src_origin, const size_t *dst_origin,
const size_t *region,
size_t src_row_pitch, size_t src_slice_pitch,
@ -301,18 +292,18 @@ clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem src_mem,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &src_mem = obj(d_src_mem);
auto &dst_mem = obj(d_dst_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, src_mem);
validate_obj(q, dst_mem);
validate_common(q, { src_mem, dst_mem }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_COPY_BUFFER_RECT, deps,
soft_copy_op(d_q,
dst_mem, vector(dst_origin),
soft_copy_op(q,
&dst_mem, vector(dst_origin),
{{ 1, dst_row_pitch, dst_slice_pitch }},
src_mem, vector(src_origin),
&src_mem, vector(src_origin),
{{ 1, src_row_pitch, src_slice_pitch }},
vector(region)));
@ -324,28 +315,27 @@ clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem src_mem,
}
PUBLIC cl_int
clEnqueueReadImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueReadImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *origin, const size_t *region,
size_t row_pitch, size_t slice_pitch, void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &img = obj<image>(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *img = dynamic_cast<image *>(mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, img);
validate_common(q, { img }, deps);
if (!ptr)
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_READ_IMAGE, deps,
soft_copy_op(d_q,
soft_copy_op(q,
ptr, {},
{{ 1, row_pitch, slice_pitch }},
mem, vector(origin),
{{ 1, img->row_pitch(), img->slice_pitch() }},
&img, vector(origin),
{{ 1, img.row_pitch(), img.slice_pitch() }},
vector(region)));
ret_object(rd_ev, hev);
@ -356,26 +346,25 @@ clEnqueueReadImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueWriteImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueWriteImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *origin, const size_t *region,
size_t row_pitch, size_t slice_pitch, const void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &img = obj<image>(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *img = dynamic_cast<image *>(mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, img);
validate_common(q, { img }, deps);
if (!ptr)
throw error(CL_INVALID_VALUE);
hard_event *hev = new hard_event(
q, CL_COMMAND_WRITE_IMAGE, deps,
soft_copy_op(d_q,
mem, vector(origin),
{{ 1, img->row_pitch(), img->slice_pitch() }},
soft_copy_op(q,
&img, vector(origin),
{{ 1, img.row_pitch(), img.slice_pitch() }},
ptr, {},
{{ 1, row_pitch, slice_pitch }},
vector(region)));
@ -388,25 +377,23 @@ clEnqueueWriteImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueCopyImage(cl_command_queue d_q, cl_mem src_mem, cl_mem dst_mem,
clEnqueueCopyImage(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
const size_t *src_origin, const size_t *dst_origin,
const size_t *region,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &src_img = obj<image>(d_src_mem);
auto &dst_img = obj<image>(d_dst_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *src_img = dynamic_cast<image *>(src_mem);
image *dst_img = dynamic_cast<image *>(dst_mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, src_img);
validate_obj(q, dst_img);
validate_common(q, { src_img, dst_img }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_COPY_IMAGE, deps,
hard_copy_op(q,
dst_img, vector(dst_origin),
src_img, vector(src_origin),
&dst_img, vector(dst_origin),
&src_img, vector(src_origin),
vector(region)));
ret_object(rd_ev, hev);
@ -418,26 +405,25 @@ clEnqueueCopyImage(cl_command_queue d_q, cl_mem src_mem, cl_mem dst_mem,
PUBLIC cl_int
clEnqueueCopyImageToBuffer(cl_command_queue d_q,
cl_mem src_mem, cl_mem dst_mem,
cl_mem d_src_mem, cl_mem d_dst_mem,
const size_t *src_origin, const size_t *region,
size_t dst_offset,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &src_img = obj<image>(d_src_mem);
auto &dst_mem = obj(d_dst_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *src_img = dynamic_cast<image *>(src_mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, src_img);
validate_obj(q, dst_mem);
validate_common(q, { src_img, dst_mem }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_COPY_IMAGE_TO_BUFFER, deps,
soft_copy_op(d_q,
dst_mem, {{ dst_offset }},
soft_copy_op(q,
&dst_mem, {{ dst_offset }},
{{ 0, 0, 0 }},
src_mem, vector(src_origin),
{{ 1, src_img->row_pitch(), src_img->slice_pitch() }},
&src_img, vector(src_origin),
{{ 1, src_img.row_pitch(), src_img.slice_pitch() }},
vector(region)));
ret_object(rd_ev, hev);
@ -449,25 +435,24 @@ clEnqueueCopyImageToBuffer(cl_command_queue d_q,
PUBLIC cl_int
clEnqueueCopyBufferToImage(cl_command_queue d_q,
cl_mem src_mem, cl_mem dst_mem,
cl_mem d_src_mem, cl_mem d_dst_mem,
size_t src_offset,
const size_t *dst_origin, const size_t *region,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &src_mem = obj(d_src_mem);
auto &dst_img = obj<image>(d_dst_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *dst_img = dynamic_cast<image *>(dst_mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, src_mem);
validate_obj(q, dst_img);
validate_common(q, { src_mem, dst_img }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_COPY_BUFFER_TO_IMAGE, deps,
soft_copy_op(d_q,
dst_mem, vector(dst_origin),
{{ 1, dst_img->row_pitch(), dst_img->slice_pitch() }},
src_mem, {{ src_offset }},
soft_copy_op(q,
&dst_img, vector(dst_origin),
{{ 1, dst_img.row_pitch(), dst_img.slice_pitch() }},
&src_mem, {{ src_offset }},
{{ 0, 0, 0 }},
vector(region)));
@ -479,20 +464,20 @@ clEnqueueCopyBufferToImage(cl_command_queue d_q,
}
PUBLIC void *
clEnqueueMapBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueMapBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
cl_map_flags flags, size_t offset, size_t size,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev, cl_int *r_errcode) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
if (offset > mem->size() || offset + size > mem->size())
if (offset > mem.size() || offset + size > mem.size())
throw error(CL_INVALID_VALUE);
void *map = mem->resource(q).add_map(
void *map = mem.resource(q).add_map(
q, flags, blocking, {{ offset }}, {{ size }});
ret_object(rd_ev, new hard_event(q, CL_COMMAND_MAP_BUFFER, deps));
@ -505,20 +490,19 @@ clEnqueueMapBuffer(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC void *
clEnqueueMapImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
clEnqueueMapImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
cl_map_flags flags,
const size_t *origin, const size_t *region,
size_t *row_pitch, size_t *slice_pitch,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev, cl_int *r_errcode) try {
auto &q = obj(d_q);
auto &img = obj<image>(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
image *img = dynamic_cast<image *>(mem);
validate_base(q, num_deps, d_deps);
validate_obj(q, img);
validate_common(q, { img }, deps);
void *map = img->resource(q).add_map(
void *map = img.resource(q).add_map(
q, flags, blocking, vector(origin), vector(region));
ret_object(rd_ev, new hard_event(q, CL_COMMAND_MAP_IMAGE, deps));
@ -531,19 +515,19 @@ clEnqueueMapImage(cl_command_queue d_q, cl_mem mem, cl_bool blocking,
}
PUBLIC cl_int
clEnqueueUnmapMemObject(cl_command_queue d_q, cl_mem mem, void *ptr,
clEnqueueUnmapMemObject(cl_command_queue d_q, cl_mem d_mem, void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
auto &q = obj(d_q);
auto &mem = obj(d_mem);
auto deps = objs<wait_list_tag>(d_deps, num_deps);
validate_base(q, num_deps, d_deps);
validate_obj(q, mem);
validate_common(q, { mem }, deps);
hard_event *hev = new hard_event(
q, CL_COMMAND_UNMAP_MEM_OBJECT, deps,
[=, &q, &mem](event &) {
mem->resource(q).del_map(ptr);
mem.resource(q).del_map(ptr);
});
ret_object(rd_ev, hev);

2
src/gallium/state_trackers/clover/core/error.hpp
View file

@ -35,7 +35,7 @@ namespace clover {
class hard_event;
class soft_event;
class kernel;
typedef struct _cl_mem memory_obj;
class memory_obj;
class buffer;
class root_buffer;
class sub_buffer;

20
src/gallium/state_trackers/clover/core/kernel.cpp
View file

@ -305,10 +305,7 @@ kernel::global_argument::set(size_t size, const void *value) {
if (size != sizeof(cl_mem))
throw error(CL_INVALID_ARG_SIZE);
buf = dynamic_cast<buffer *>(*(cl_mem *)value);
if (!buf)
throw error(CL_INVALID_MEM_OBJECT);
buf = &obj<buffer>(*(cl_mem *)value);
_set = true;
}
@ -360,10 +357,7 @@ kernel::constant_argument::set(size_t size, const void *value) {
if (size != sizeof(cl_mem))
throw error(CL_INVALID_ARG_SIZE);
buf = dynamic_cast<buffer *>(*(cl_mem *)value);
if (!buf)
throw error(CL_INVALID_MEM_OBJECT);
buf = &obj<buffer>(*(cl_mem *)value);
_set = true;
}
@ -391,10 +385,7 @@ kernel::image_rd_argument::set(size_t size, const void *value) {
if (size != sizeof(cl_mem))
throw error(CL_INVALID_ARG_SIZE);
img = dynamic_cast<image *>(*(cl_mem *)value);
if (!img)
throw error(CL_INVALID_MEM_OBJECT);
img = &obj<image>(*(cl_mem *)value);
_set = true;
}
@ -422,10 +413,7 @@ kernel::image_wr_argument::set(size_t size, const void *value) {
if (size != sizeof(cl_mem))
throw error(CL_INVALID_ARG_SIZE);
img = dynamic_cast<image *>(*(cl_mem *)value);
if (!img)
throw error(CL_INVALID_MEM_OBJECT);
img = &obj<image>(*(cl_mem *)value);
_set = true;
}

32
src/gallium/state_trackers/clover/core/memory.cpp
View file

@ -25,8 +25,8 @@
using namespace clover;
_cl_mem::_cl_mem(clover::context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr) :
memory_obj::memory_obj(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr) :
ctx(ctx), _flags(flags),
_size(size), _host_ptr(host_ptr),
_destroy_notify([]{}) {
@ -34,31 +34,31 @@ _cl_mem::_cl_mem(clover::context &ctx, cl_mem_flags flags,
data.append((char *)host_ptr, size);
}
_cl_mem::~_cl_mem() {
memory_obj::~memory_obj() {
_destroy_notify();
}
void
_cl_mem::destroy_notify(std::function<void ()> f) {
memory_obj::destroy_notify(std::function<void ()> f) {
_destroy_notify = f;
}
cl_mem_flags
_cl_mem::flags() const {
memory_obj::flags() const {
return _flags;
}
size_t
_cl_mem::size() const {
memory_obj::size() const {
return _size;
}
void *
_cl_mem::host_ptr() const {
memory_obj::host_ptr() const {
return _host_ptr;
}
buffer::buffer(clover::context &ctx, cl_mem_flags flags,
buffer::buffer(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr) :
memory_obj(ctx, flags, size, host_ptr) {
}
@ -68,12 +68,12 @@ buffer::type() const {
return CL_MEM_OBJECT_BUFFER;
}
root_buffer::root_buffer(clover::context &ctx, cl_mem_flags flags,
root_buffer::root_buffer(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr) :
buffer(ctx, flags, size, host_ptr) {
}
clover::resource &
resource &
root_buffer::resource(command_queue &q) {
// Create a new resource if there's none for this device yet.
if (!resources.count(&q.dev)) {
@ -89,14 +89,14 @@ root_buffer::resource(command_queue &q) {
return *resources.find(&q.dev)->second;
}
sub_buffer::sub_buffer(clover::root_buffer &parent, cl_mem_flags flags,
sub_buffer::sub_buffer(root_buffer &parent, cl_mem_flags flags,
size_t offset, size_t size) :
buffer(parent.ctx, flags, size,
(char *)parent.host_ptr() + offset),
parent(parent), _offset(offset) {
}
clover::resource &
resource &
sub_buffer::resource(command_queue &q) {
// Create a new resource if there's none for this device yet.
if (!resources.count(&q.dev)) {
@ -114,7 +114,7 @@ sub_buffer::offset() const {
return _offset;
}
image::image(clover::context &ctx, cl_mem_flags flags,
image::image(context &ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
size_t row_pitch, size_t slice_pitch, size_t size,
@ -124,7 +124,7 @@ image::image(clover::context &ctx, cl_mem_flags flags,
_row_pitch(row_pitch), _slice_pitch(slice_pitch) {
}
clover::resource &
resource &
image::resource(command_queue &q) {
// Create a new resource if there's none for this device yet.
if (!resources.count(&q.dev)) {
@ -170,7 +170,7 @@ image::slice_pitch() const {
return _slice_pitch;
}
image2d::image2d(clover::context &ctx, cl_mem_flags flags,
image2d::image2d(context &ctx, cl_mem_flags flags,
const cl_image_format *format, size_t width,
size_t height, size_t row_pitch,
void *host_ptr) :
@ -183,7 +183,7 @@ image2d::type() const {
return CL_MEM_OBJECT_IMAGE2D;
}
image3d::image3d(clover::context &ctx, cl_mem_flags flags,
image3d::image3d(context &ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
size_t row_pitch, size_t slice_pitch,

106
src/gallium/state_trackers/clover/core/memory.hpp
View file

@ -31,89 +31,85 @@
#include "core/queue.hpp"
namespace clover {
typedef struct _cl_mem memory_obj;
class resource;
class sub_resource;
}
struct _cl_mem : public clover::ref_counter {
protected:
_cl_mem(clover::context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr);
_cl_mem(const _cl_mem &obj) = delete;
public:
virtual ~_cl_mem();
virtual cl_mem_object_type type() const = 0;
virtual clover::resource &resource(clover::command_queue &q) = 0;
void destroy_notify(std::function<void ()> f);
cl_mem_flags flags() const;
size_t size() const;
void *host_ptr() const;
clover::context &ctx;
private:
cl_mem_flags _flags;
size_t _size;
void *_host_ptr;
std::function<void ()> _destroy_notify;
protected:
std::string data;
};
namespace clover {
struct buffer : public memory_obj {
class memory_obj : public ref_counter, public _cl_mem {
protected:
buffer(clover::context &ctx, cl_mem_flags flags,
memory_obj(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr);
memory_obj(const memory_obj &obj) = delete;
public:
virtual ~memory_obj();
virtual cl_mem_object_type type() const = 0;
virtual clover::resource &resource(command_queue &q) = 0;
void destroy_notify(std::function<void ()> f);
cl_mem_flags flags() const;
size_t size() const;
void *host_ptr() const;
context &ctx;
private:
cl_mem_flags _flags;
size_t _size;
void *_host_ptr;
std::function<void ()> _destroy_notify;
protected:
std::string data;
};
class buffer : public memory_obj {
protected:
buffer(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr);
public:
virtual cl_mem_object_type type() const;
};
struct root_buffer : public buffer {
class root_buffer : public buffer {
public:
root_buffer(clover::context &ctx, cl_mem_flags flags,
root_buffer(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr);
virtual clover::resource &resource(clover::command_queue &q);
virtual clover::resource &resource(command_queue &q);
private:
std::map<clover::device *,
std::unique_ptr<clover::root_resource>> resources;
std::map<device *,
std::unique_ptr<root_resource>> resources;
};
struct sub_buffer : public buffer {
class sub_buffer : public buffer {
public:
sub_buffer(clover::root_buffer &parent, cl_mem_flags flags,
sub_buffer(root_buffer &parent, cl_mem_flags flags,
size_t offset, size_t size);
virtual clover::resource &resource(clover::command_queue &q);
virtual clover::resource &resource(command_queue &q);
size_t offset() const;
clover::root_buffer &parent;
root_buffer &parent;
private:
size_t _offset;
std::map<clover::device *,
std::unique_ptr<clover::sub_resource>> resources;
std::map<device *,
std::unique_ptr<sub_resource>> resources;
};
struct image : public memory_obj {
class image : public memory_obj {
protected:
image(clover::context &ctx, cl_mem_flags flags,
image(context &ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
size_t row_pitch, size_t slice_pitch, size_t size,
void *host_ptr);
public:
virtual clover::resource &resource(clover::command_queue &q);
virtual clover::resource &resource(command_queue &q);
cl_image_format format() const;
size_t width() const;
size_t height() const;
@ -128,13 +124,13 @@ namespace clover {
size_t _depth;
size_t _row_pitch;
size_t _slice_pitch;
std::map<clover::device *,
std::unique_ptr<clover::root_resource>> resources;
std::map<device *,
std::unique_ptr<root_resource>> resources;
};
struct image2d : public image {
class image2d : public image {
public:
image2d(clover::context &ctx, cl_mem_flags flags,
image2d(context &ctx, cl_mem_flags flags,
const cl_image_format *format, size_t width,
size_t height, size_t row_pitch,
void *host_ptr);
@ -142,9 +138,9 @@ namespace clover {
virtual cl_mem_object_type type() const;
};
struct image3d : public image {
class image3d : public image {
public:
image3d(clover::context &ctx, cl_mem_flags flags,
image3d(context &ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
size_t row_pitch, size_t slice_pitch,

3
src/gallium/state_trackers/clover/core/object.hpp
View file

@ -191,6 +191,9 @@ struct _cl_event :
struct _cl_kernel :
public clover::descriptor<clover::kernel, _cl_kernel> {};
struct _cl_mem :
public clover::descriptor<clover::memory_obj, _cl_mem> {};
struct _cl_platform_id :
public clover::descriptor<clover::platform, _cl_platform_id> {};

20
src/gallium/state_trackers/clover/core/resource.cpp
View file

@ -21,7 +21,6 @@
//
#include "core/resource.hpp"
#include "util/algorithm.hpp"
#include "pipe/p_screen.h"
#include "util/u_sampler.h"
#include "util/u_format.h"
@ -46,7 +45,7 @@ namespace {
};
}
resource::resource(clover::device &dev, clover::memory_obj &obj) :
resource::resource(device &dev, memory_obj &obj) :
dev(dev), obj(obj), pipe(NULL), offset() {
}
@ -83,7 +82,7 @@ resource::map_count() const {
}
pipe_sampler_view *
resource::bind_sampler_view(clover::command_queue &q) {
resource::bind_sampler_view(command_queue &q) {
pipe_sampler_view info;
u_sampler_view_default_template(&info, pipe, pipe->format);
@ -91,13 +90,13 @@ resource::bind_sampler_view(clover::command_queue &q) {
}
void
resource::unbind_sampler_view(clover::command_queue &q,
resource::unbind_sampler_view(command_queue &q,
pipe_sampler_view *st) {
q.pipe->sampler_view_destroy(q.pipe, st);
}
pipe_surface *
resource::bind_surface(clover::command_queue &q, bool rw) {
resource::bind_surface(command_queue &q, bool rw) {
pipe_surface info {};
info.format = pipe->format;
@ -110,13 +109,12 @@ resource::bind_surface(clover::command_queue &q, bool rw) {
}
void
resource::unbind_surface(clover::command_queue &q, pipe_surface *st) {
resource::unbind_surface(command_queue &q, pipe_surface *st) {
q.pipe->surface_destroy(q.pipe, st);
}
root_resource::root_resource(clover::device &dev, clover::memory_obj &obj,
clover::command_queue &q,
const std::string &data) :
root_resource::root_resource(device &dev, memory_obj &obj,
command_queue &q, const std::string &data) :
resource(dev, obj) {
pipe_resource info {};
@ -152,8 +150,8 @@ root_resource::root_resource(clover::device &dev, clover::memory_obj &obj,
}
}
root_resource::root_resource(clover::device &dev, clover::memory_obj &obj,
clover::root_resource &r) :
root_resource::root_resource(device &dev, memory_obj &obj,
root_resource &r) :
resource(dev, obj) {
assert(0); // XXX -- resource shared among dev and r.dev
}

22
src/gallium/state_trackers/clover/core/resource.hpp
View file

@ -52,22 +52,22 @@ namespace clover {
void del_map(void *p);
unsigned map_count() const;
clover::device &dev;
clover::memory_obj &obj;
device &dev;
memory_obj &obj;
friend class sub_resource;
friend class mapping;
friend class kernel;
protected:
resource(clover::device &dev, clover::memory_obj &obj);
resource(device &dev, clover::memory_obj &obj);
pipe_sampler_view *bind_sampler_view(clover::command_queue &q);
void unbind_sampler_view(clover::command_queue &q,
pipe_sampler_view *bind_sampler_view(command_queue &q);
void unbind_sampler_view(command_queue &q,
pipe_sampler_view *st);
pipe_surface *bind_surface(clover::command_queue &q, bool rw);
void unbind_surface(clover::command_queue &q, pipe_surface *st);
pipe_surface *bind_surface(command_queue &q, bool rw);
void unbind_surface(command_queue &q, pipe_surface *st);
pipe_resource *pipe;
vector offset;
@ -82,9 +82,9 @@ namespace clover {
///
class root_resource : public resource {
public:
root_resource(clover::device &dev, clover::memory_obj &obj,
clover::command_queue &q, const std::string &data);
root_resource(clover::device &dev, clover::memory_obj &obj,
root_resource(device &dev, memory_obj &obj,
command_queue &q, const std::string &data);
root_resource(device &dev, memory_obj &obj,
root_resource &r);
virtual ~root_resource();
};
@ -95,7 +95,7 @@ namespace clover {
///
class sub_resource : public resource {
public:
sub_resource(clover::resource &r, const vector &offset);
sub_resource(resource &r, const vector &offset);
};
///