clover: Replace the transfer(new ...) idiom with a safer create(...) helper function.

Tested-by: Tom Stellard <thomas.stellard@amd.com>

diff --git a/src/gallium/state_trackers/clover/api/event.cpp b/src/gallium/state_trackers/clover/api/event.cpp
index 7057b77db1eab6d1f750678a670359c1f1a9ef4d..6b1956c8f2f4298313c981de0a09ae92f358baa5 100644 (file)
--- a/src/gallium/state_trackers/clover/api/event.cpp
+++ b/src/gallium/state_trackers/clover/api/event.cpp
@@ -72,11 +72,10 @@ clWaitForEvents(cl_uint num_evs, const cl_event *d_evs) try {
 
    // Create a temporary soft event that depends on all the events in
    // the wait list
-   intrusive_ptr<soft_event> sev =
-      transfer(new soft_event(evs.front().context(), evs, true));
+   auto sev = create<soft_event>(evs.front().context(), evs, true);
 
    // ...and wait on it.
-   sev->wait();
+   sev().wait();
 
    return CL_SUCCESS;
 
@@ -132,12 +131,11 @@ clSetEventCallback(cl_event d_ev, cl_int type,
 
    // Create a temporary soft event that depends on ev, with
    // pfn_notify as completion action.
-   intrusive_ptr<soft_event> sev = transfer(
-      new soft_event(ev.context(), { ev }, true,
-                     [=, &ev](event &) {
-                        ev.wait();
-                        pfn_notify(desc(ev), ev.status(), user_data);
-                     }));
+   create<soft_event>(ev.context(), ref_vector<event> { ev }, true,
+                      [=, &ev](event &) {
+                         ev.wait();
+                         pfn_notify(desc(ev), ev.status(), user_data);
+                      });
 
    return CL_SUCCESS;
 
@@ -206,7 +204,7 @@ clEnqueueWaitForEvents(cl_command_queue d_q, cl_uint num_evs,
    // Create a hard event that depends on the events in the wait list:
    // subsequent commands in the same queue will be implicitly
    // serialized with respect to it -- hard events always are.
-   intrusive_ptr<hard_event> hev = transfer(new hard_event(q, 0, evs));
+   create<hard_event>(q, 0, evs);
 
    return CL_SUCCESS;
 
@@ -262,10 +260,10 @@ clFinish(cl_command_queue d_q) try {
 
    // Create a temporary hard event -- it implicitly depends on all
    // the previously queued hard events.
-   intrusive_ptr<hard_event> hev = transfer(new hard_event(q, 0, { }));
+   auto hev = create<hard_event>(q, 0, ref_vector<event> {});
 
    // And wait on it.
-   hev->wait();
+   hev().wait();
 
    return CL_SUCCESS;
 

diff --git a/src/gallium/state_trackers/clover/api/kernel.cpp b/src/gallium/state_trackers/clover/api/kernel.cpp
index f1a9bd84d34b42bcb8fceb383aff956020326b27..96cf302b1612dafc269ebb359e2d3e3c92861d8d 100644 (file)
--- a/src/gallium/state_trackers/clover/api/kernel.cpp
+++ b/src/gallium/state_trackers/clover/api/kernel.cpp
@@ -276,7 +276,7 @@ clEnqueueNDRangeKernel(cl_command_queue d_q, cl_kernel d_kern,
 
    validate_common(q, kern, deps);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_NDRANGE_KERNEL, deps,
       [=, &kern, &q](event &) {
          kern.launch(q, grid_offset, grid_size, block_size);
@@ -299,7 +299,7 @@ clEnqueueTask(cl_command_queue d_q, cl_kernel d_kern,
 
    validate_common(q, kern, deps);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_TASK, deps,
       [=, &kern, &q](event &) {
          kern.launch(q, { 0 }, { 1 }, { 1 });

diff --git a/src/gallium/state_trackers/clover/api/transfer.cpp b/src/gallium/state_trackers/clover/api/transfer.cpp
index 02d0dd0a71d22da455c6a40834d129ada9a807b5..72f0b3041a9dbd6a1b49a4fcf2bad60e759f7a9d 100644 (file)
--- a/src/gallium/state_trackers/clover/api/transfer.cpp
+++ b/src/gallium/state_trackers/clover/api/transfer.cpp
@@ -246,7 +246,7 @@ clEnqueueReadBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, ptr, {}, obj_pitch, region);
    validate_object(q, mem, obj_origin, obj_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_READ_BUFFER, deps,
       soft_copy_op(q, ptr, {}, obj_pitch,
                    &mem, obj_origin, obj_pitch,
@@ -275,7 +275,7 @@ clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, mem, obj_origin, obj_pitch, region);
    validate_object(q, ptr, {}, obj_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_WRITE_BUFFER, deps,
       soft_copy_op(q, &mem, obj_origin, obj_pitch,
                    ptr, {}, obj_pitch,
@@ -311,7 +311,7 @@ clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, ptr, host_origin, host_pitch, region);
    validate_object(q, mem, obj_origin, obj_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_READ_BUFFER_RECT, deps,
       soft_copy_op(q, ptr, host_origin, host_pitch,
                    &mem, obj_origin, obj_pitch,
@@ -347,7 +347,7 @@ clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, mem, obj_origin, obj_pitch, region);
    validate_object(q, ptr, host_origin, host_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_WRITE_BUFFER_RECT, deps,
       soft_copy_op(q, &mem, obj_origin, obj_pitch,
                    ptr, host_origin, host_pitch,
@@ -381,7 +381,7 @@ clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
    validate_copy(q, dst_mem, dst_origin, dst_pitch,
                  src_mem, src_origin, src_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_COPY_BUFFER, deps,
       hard_copy_op(q, &dst_mem, dst_origin,
                    &src_mem, src_origin, region));
@@ -418,7 +418,7 @@ clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem d_src_mem,
    validate_copy(q, dst_mem, dst_origin, dst_pitch,
                  src_mem, src_origin, src_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_COPY_BUFFER_RECT, deps,
       soft_copy_op(q, &dst_mem, dst_origin, dst_pitch,
                    &src_mem, src_origin, src_pitch,
@@ -451,7 +451,7 @@ clEnqueueReadImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, ptr, {}, dst_pitch, region);
    validate_object(q, img, src_origin, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_READ_IMAGE, deps,
       soft_copy_op(q, ptr, {}, dst_pitch,
                    &img, src_origin, src_pitch,
@@ -484,7 +484,7 @@ clEnqueueWriteImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
    validate_object(q, img, dst_origin, region);
    validate_object(q, ptr, {}, src_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_WRITE_IMAGE, deps,
       soft_copy_op(q, &img, dst_origin, dst_pitch,
                    ptr, {}, src_pitch,
@@ -516,7 +516,7 @@ clEnqueueCopyImage(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
    validate_object(q, src_img, src_origin, region);
    validate_copy(q, dst_img, dst_origin, src_img, src_origin, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_COPY_IMAGE, deps,
       hard_copy_op(q, &dst_img, dst_origin,
                    &src_img, src_origin,
@@ -552,7 +552,7 @@ clEnqueueCopyImageToBuffer(cl_command_queue d_q,
    validate_object(q, dst_mem, dst_origin, dst_pitch, region);
    validate_object(q, src_img, src_origin, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_COPY_IMAGE_TO_BUFFER, deps,
       soft_copy_op(q, &dst_mem, dst_origin, dst_pitch,
                    &src_img, src_origin, src_pitch,
@@ -588,7 +588,7 @@ clEnqueueCopyBufferToImage(cl_command_queue d_q,
    validate_object(q, dst_img, dst_origin, region);
    validate_object(q, src_mem, src_origin, src_pitch, region);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_COPY_BUFFER_TO_IMAGE, deps,
       soft_copy_op(q, &dst_img, dst_origin, dst_pitch,
                    &src_mem, src_origin, src_pitch,
@@ -618,7 +618,7 @@ clEnqueueMapBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
 
    void *map = mem.resource(q).add_map(q, flags, blocking, obj_origin, region);
 
-   ret_object(rd_ev, new hard_event(q, CL_COMMAND_MAP_BUFFER, deps));
+   ret_object(rd_ev, create<hard_event>(q, CL_COMMAND_MAP_BUFFER, deps));
    ret_error(r_errcode, CL_SUCCESS);
    return map;
 
@@ -645,7 +645,7 @@ clEnqueueMapImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
 
    void *map = img.resource(q).add_map(q, flags, blocking, origin, region);
 
-   ret_object(rd_ev, new hard_event(q, CL_COMMAND_MAP_IMAGE, deps));
+   ret_object(rd_ev, create<hard_event>(q, CL_COMMAND_MAP_IMAGE, deps));
    ret_error(r_errcode, CL_SUCCESS);
    return map;
 
@@ -664,7 +664,7 @@ clEnqueueUnmapMemObject(cl_command_queue d_q, cl_mem d_mem, void *ptr,
 
    validate_common(q, deps);
 
-   hard_event *hev = new hard_event(
+   auto hev = create<hard_event>(
       q, CL_COMMAND_UNMAP_MEM_OBJECT, deps,
       [=, &q, &mem](event &) {
          mem.resource(q).del_map(ptr);

diff --git a/src/gallium/state_trackers/clover/api/util.hpp b/src/gallium/state_trackers/clover/api/util.hpp
index 60c8709cc0535bbd8d337fc3f6175f0749cb737d..c2b216ec236a04e7e733a431137fa12aea992bb8 100644 (file)
--- a/src/gallium/state_trackers/clover/api/util.hpp
+++ b/src/gallium/state_trackers/clover/api/util.hpp
@@ -48,16 +48,17 @@ namespace clover {
    }
 
    ///
-   /// Return a reference-counted object in \a p if non-zero.
-   /// Otherwise release object ownership.
+   /// Return a clover object in \a p if non-zero incrementing the
+   /// reference count of the object.
    ///
-   template<typename T, typename S>
+   template<typename T>
    void
-   ret_object(T p, S v) {
-      if (p)
-         *p = v;
-      else
-         v->release();
+   ret_object(typename T::descriptor_type **p,
+              const intrusive_ref<T> &v) {
+      if (p) {
+         v().retain();
+         *p = desc(v());
+      }
    }
 }
 

diff --git a/src/gallium/state_trackers/clover/core/platform.cpp b/src/gallium/state_trackers/clover/core/platform.cpp
index 0a12a61b3986a8e869d8c2a89a1cf3ba8e8ac947..328b71cdcb1bc1e6b7a7ff92117051deb4c12b1f 100644 (file)
--- a/src/gallium/state_trackers/clover/core/platform.cpp
+++ b/src/gallium/state_trackers/clover/core/platform.cpp
@@ -32,7 +32,7 @@ platform::platform() : adaptor_range(evals(), devs) {
 
    for (pipe_loader_device *ldev : ldevs) {
       try {
-         devs.push_back(transfer(*new device(*this, ldev)));
+         devs.push_back(create<device>(*this, ldev));
       } catch (error &) {
          pipe_loader_release(&ldev, 1);
       }

diff --git a/src/gallium/state_trackers/clover/util/pointer.hpp b/src/gallium/state_trackers/clover/util/pointer.hpp
index 98823aa78609c354c2d52a4e14d3df7003459740..59c6e6e9f643d61ed112e74e54c51395a9753786 100644 (file)
--- a/src/gallium/state_trackers/clover/util/pointer.hpp
+++ b/src/gallium/state_trackers/clover/util/pointer.hpp
@@ -121,18 +121,6 @@ namespace clover {
       T *p;
    };
 
-   ///
-   /// Transfer the caller's ownership of a reference-counted object
-   /// to a clover::intrusive_ptr smart pointer.
-   ///
-   template<typename T>
-   inline intrusive_ptr<T>
-   transfer(T *p) {
-      intrusive_ptr<T> ref { p };
-      p->release();
-      return ref;
-   }
-
    ///
    /// Intrusive smart reference for objects that implement the
    /// clover::ref_counter interface.
@@ -188,14 +176,14 @@ namespace clover {
    };
 
    ///
-   /// Transfer the caller's ownership of a reference-counted object
-   /// to a clover::intrusive_ref smart reference.
+   /// Initialize a clover::intrusive_ref from a newly created object
+   /// using the specified constructor arguments.
    ///
-   template<typename T>
-   inline intrusive_ref<T>
-   transfer(T &o) {
-      intrusive_ref<T> ref { o };
-      o.release();
+   template<typename T, typename... As>
+   intrusive_ref<T>
+   create(As &&... as) {
+      intrusive_ref<T> ref { *new T(std::forward<As>(as)...) };
+      ref().release();
       return ref;
    }