clover: Some improvements for the intrusive pointer class.

Define some additional convenience operators, clean up the
implementation slightly, and rename it to 'intrusive_ptr' for reasons
that will be obvious in the next commit.

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 1aff2c50238f113d61bc04dc251799413052343b..05534c74c99c715cdfebe22dd42d1e72522a5106 100644 (file)
--- a/src/gallium/state_trackers/clover/api/event.cpp
+++ b/src/gallium/state_trackers/clover/api/event.cpp
@@ -72,7 +72,7 @@ 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
-   ref_ptr<soft_event> sev =
+   intrusive_ptr<soft_event> sev =
       transfer(new soft_event(evs.front().ctx, evs, true));
 
    // ...and wait on it.
@@ -132,7 +132,7 @@ clSetEventCallback(cl_event d_ev, cl_int type,
 
    // Create a temporary soft event that depends on ev, with
    // pfn_notify as completion action.
-   ref_ptr<soft_event> sev = transfer(
+   intrusive_ptr<soft_event> sev = transfer(
       new soft_event(ev.ctx, { ev }, true,
                      [=, &ev](event &) {
                         ev.wait();
@@ -206,7 +206,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.
-   ref_ptr<hard_event> hev = transfer(new hard_event(q, 0, evs));
+   intrusive_ptr<hard_event> hev = transfer(new hard_event(q, 0, evs));
 
    return CL_SUCCESS;
 
@@ -262,7 +262,7 @@ clFinish(cl_command_queue d_q) try {
 
    // Create a temporary hard event -- it implicitly depends on all
    // the previously queued hard events.
-   ref_ptr<hard_event> hev = transfer(new hard_event(q, 0, { }));
+   intrusive_ptr<hard_event> hev = transfer(new hard_event(q, 0, { }));
 
    // And wait on it.
    hev->wait();

diff --git a/src/gallium/state_trackers/clover/core/event.cpp b/src/gallium/state_trackers/clover/core/event.cpp
index 97f56357566c97bc492ebc9a1fc37eed30812845..3f3e05e289a95043dc59b43e0b9c7ac485b1c8c3 100644 (file)
--- a/src/gallium/state_trackers/clover/core/event.cpp
+++ b/src/gallium/state_trackers/clover/core/event.cpp
@@ -186,7 +186,7 @@ soft_event::status() const {
       return _status;
 
    else if (!signalled() ||
-            any_of([](const ref_ptr<event> &ev) {
+            any_of([](const intrusive_ptr<event> &ev) {
                   return ev->status() != CL_COMPLETE;
                }, deps))
       return CL_SUBMITTED;

diff --git a/src/gallium/state_trackers/clover/core/event.hpp b/src/gallium/state_trackers/clover/core/event.hpp
index 05bdd2f961f00e3552a068fc85f595093510b1e5..123304bacc3cc0a22169663feb19ecb3804d652d 100644 (file)
--- a/src/gallium/state_trackers/clover/core/event.hpp
+++ b/src/gallium/state_trackers/clover/core/event.hpp
@@ -76,13 +76,13 @@ namespace clover {
       void chain(event *ev);
 
       cl_int _status;
-      std::vector<ref_ptr<event>> deps;
+      std::vector<intrusive_ptr<event>> deps;
 
    private:
       unsigned wait_count;
       action action_ok;
       action action_fail;
-      std::vector<ref_ptr<event>> _chain;
+      std::vector<intrusive_ptr<event>> _chain;
    };
 
    ///

diff --git a/src/gallium/state_trackers/clover/core/platform.hpp b/src/gallium/state_trackers/clover/core/platform.hpp
index c16229a7512daf87fb68f6eaa214900d68351bb3..bcc8e0c1cb5a637e0c6fec2463b063fe7c56d9af 100644 (file)
--- a/src/gallium/state_trackers/clover/core/platform.hpp
+++ b/src/gallium/state_trackers/clover/core/platform.hpp
@@ -32,7 +32,7 @@
 namespace clover {
    class platform : public _cl_platform_id,
                     public adaptor_range<
-      derefs, std::vector<ref_ptr<device>> &> {
+      derefs, std::vector<intrusive_ptr<device>> &> {
    public:
       platform();
 
@@ -41,7 +41,7 @@ namespace clover {
       operator=(const platform &platform) = delete;
 
    protected:
-      std::vector<ref_ptr<device>> devs;
+      std::vector<intrusive_ptr<device>> devs;
    };
 }
 

diff --git a/src/gallium/state_trackers/clover/core/queue.hpp b/src/gallium/state_trackers/clover/core/queue.hpp
index e3c4ceb774463debfec1f23bf2fa19120932eb0a..81b9781cf47d0bca4f326e191ac1c908b8399699 100644 (file)
--- a/src/gallium/state_trackers/clover/core/queue.hpp
+++ b/src/gallium/state_trackers/clover/core/queue.hpp
@@ -69,9 +69,7 @@ namespace clover {
 
       cl_command_queue_properties _props;
       pipe_context *pipe;
-
-      typedef ref_ptr<hard_event> event_ptr;
-      std::deque<event_ptr> queued_events;
+      std::deque<intrusive_ptr<hard_event>> queued_events;
    };
 }
 

diff --git a/src/gallium/state_trackers/clover/util/pointer.hpp b/src/gallium/state_trackers/clover/util/pointer.hpp
index f0c5b1618a5e9e207ee801eddee27aecd3fa74cb..b7a633b523cd6f1eedb72f0c4ea0ce748bee81ea 100644 (file)
--- a/src/gallium/state_trackers/clover/util/pointer.hpp
+++ b/src/gallium/state_trackers/clover/util/pointer.hpp
@@ -57,35 +57,43 @@ namespace clover {
    /// clover::ref_counter interface.
    ///
    template<typename T>
-   class ref_ptr {
+   class intrusive_ptr {
    public:
-      ref_ptr(T *q = NULL) : p(NULL) {
-         reset(q);
+      intrusive_ptr(T *q = NULL) : p(q) {
+         if (p)
+            p->retain();
       }
 
-      ref_ptr(const ref_ptr<T> &ref) : p(NULL) {
-         reset(ref.p);
+      intrusive_ptr(const intrusive_ptr &ptr) :
+         intrusive_ptr(ptr.p) {
       }
 
-      ~ref_ptr() {
-         reset(NULL);
+      intrusive_ptr(intrusive_ptr &&ptr) :
+         p(ptr.p) {
+         ptr.p = NULL;
       }
 
-      void
-      reset(T *q = NULL) {
-         if (q)
-            q->retain();
+      ~intrusive_ptr() {
          if (p && p->release())
             delete p;
-         p = q;
       }
 
-      ref_ptr &
-      operator=(const ref_ptr &ref) {
-         reset(ref.p);
+      intrusive_ptr &
+      operator=(intrusive_ptr ptr) {
+         std::swap(ptr.p, p);
          return *this;
       }
 
+      bool
+      operator==(const intrusive_ptr &ref) const {
+         return p == ref.p;
+      }
+
+      bool
+      operator!=(const intrusive_ptr &ref) const {
+         return p != ref.p;
+      }
+
       T &
       operator*() const {
          return *p;
@@ -96,22 +104,31 @@ namespace clover {
          return p;
       }
 
+      T *
+      operator()() const {
+         return p;
+      }
+
       explicit operator bool() const {
          return p;
       }
 
+      explicit operator T *() const {
+         return p;
+      }
+
    private:
       T *p;
    };
 
    ///
    /// Transfer the caller's ownership of a reference-counted object
-   /// to a clover::ref_ptr smart pointer.
+   /// to a clover::intrusive_ptr smart pointer.
    ///
    template<typename T>
-   inline ref_ptr<T>
+   inline intrusive_ptr<T>
    transfer(T *p) {
-      ref_ptr<T> ref { p };
+      intrusive_ptr<T> ref { p };
       p->release();
       return ref;
    }