Add a way to compare resources

include/camp/resource.hpp

@@ -65,7 +65,7 @@ namespace resources
         return result ? result->get() : nullptr;
       }
       template <typename T>
-      T get()
+      T get() const
       {
         auto result = dynamic_cast<ContextModel<T> *>(m_value.get());
         if (result == nullptr) {
@@ -94,29 +94,65 @@ namespace resources
       void wait_for(Event *e) { m_value->wait_for(e); }
       void wait() { m_value->wait(); }
 
+      /*
+       * \brief Compares two Resources to see if they are equal. Two Resources are equal if they are
+       * on the same platform and they describe the same stream (i.e. CUDA, HIP) or queue (i.e. SYCL).
+       * (Note: This operator overload is on the generic Resource. Using the ContextModel's operator
+       * overload, we can call the specific resource's (i.e. T) operator== to compare streams or
+       * queues.)
+       *
+       * \return True or false depending on comparison with m_value if they are on the same platform.
+       */
+      bool operator==(Resource const& r) const
+      {
+        if(get_platform() == r.get_platform()) {
+          return (m_value->compare(r));
+        }
+        return false;
+      }
+      /*
+       * \brief Compares two Resources to see if they are NOT equal. Two Resources are not equal
+       * if they are on separate platforms. Also, even if they are on the same platform, if they
+       * describe different streams (i.e. CUDA, HIP) or different queues (i.e. SYCL), then they 
+       * are not equal.
+       *
+       * \return Negation of == operator. 
+       */
+      bool operator!=(Resource const& r) const
+      {
+        return !(*this == r);
+      }
+
     private:
       class ContextInterface
       {
       public:
         virtual ~ContextInterface() {}
         virtual Platform get_platform() const = 0;
+
+        virtual bool compare(Resource const& r) const = 0;
+
         virtual void *allocate(size_t size, MemoryAccess ma = MemoryAccess::Device) = 0;
         virtual void *calloc(size_t size, MemoryAccess ma = MemoryAccess::Device) = 0;
         virtual void deallocate(void *p, MemoryAccess ma = MemoryAccess::Device) = 0;
         virtual void memcpy(void *dst, const void *src, size_t size) = 0;
         virtual void memset(void *p, int val, size_t size) = 0;
+
         virtual Event get_event() = 0;
         virtual Event get_event_erased() = 0;
         virtual void wait_for(Event *e) = 0;
         virtual void wait() = 0;
       };
 
       template <typename T>
-      class ContextModel : public ContextInterface
+      class ContextModel final : public ContextInterface
       {
       public:
         ContextModel(T const &modelVal) : m_modelVal(modelVal) {}
         Platform get_platform() const override { return m_modelVal.get_platform(); }
+
+        bool compare(Resource const& r) const override { return m_modelVal == r.get<T>(); }
+
         void *allocate(size_t size, MemoryAccess ma = MemoryAccess::Device) override { return m_modelVal.template allocate<char>(size, ma); }
         void *calloc(size_t size, MemoryAccess ma = MemoryAccess::Device) override { return m_modelVal.calloc(size, ma); }
         void deallocate(void *p, MemoryAccess ma = MemoryAccess::Device) override { m_modelVal.deallocate(p, ma); }
@@ -128,13 +164,15 @@ namespace resources
         {
           m_modelVal.memset(p, val, size);
         }
+
         Event get_event() override { return m_modelVal.get_event_erased(); }
         Event get_event_erased() override
         {
           return m_modelVal.get_event_erased();
         }
         void wait_for(Event *e) override { m_modelVal.wait_for(e); }
         void wait() override { m_modelVal.wait(); }
+
         T *get() { return &m_modelVal; }
 
       private:

include/camp/resource/cuda.hpp

@@ -256,8 +256,28 @@ namespace resources
         }
       }
 
-      cudaStream_t get_stream() { return stream; }
-      int get_device() { return device; }
+      cudaStream_t get_stream() const { return stream; }
+      int get_device() const { return device; }
+
+      /*
+       * \brief Compares two (Cuda) resources to see if they are equal.
+       *
+       * \return True or false depending on if it is the same stream.
+       */
+      bool operator==(Cuda const& c) const
+      {
+        return (get_stream() == c.get_stream());
+      }
+
+      /*
+       * \brief Compares two (Cuda) resources to see if they are NOT equal.
+       *
+       * \return Negation of == operator
+       */
+      bool operator!=(Cuda const& c) const
+      {
+        return !(*this == c);
+      }
 
     private:
       cudaStream_t stream;

include/camp/resource/hip.hpp

@@ -257,8 +257,28 @@ namespace resources
         }
       }
 
-      hipStream_t get_stream() { return stream; }
-      int get_device() { return device; }
+      hipStream_t get_stream() const { return stream; }
+      int get_device() const { return device; }
+
+      /*
+       * \brief Compares two (Hip) resources to see if they are equal.
+       *
+       * \return True or false depending on if this is the same stream.
+       */
+      bool operator==(Hip const& h) const
+      {
+        return (get_stream() == h.get_stream());
+      }
+
+      /*
+       * \brief Compares two (Hip) resources to see if they are NOT equal.
+       *
+       * \return Negation of == operator
+       */
+      bool operator!=(Hip const& h) const
+      {
+        return !(*this == h);
+      }
 
     private:
       hipStream_t stream;

include/camp/resource/host.hpp

@@ -70,6 +70,27 @@ namespace resources
       void memset(void *p, int val, size_t size) { std::memset(p, val, size); }
     };
 
+      /*
+       * \brief Compares two (Host) resources to see if they are equal.
+       * (This was made in to a free function to appease MSVC and SYCL compilers)
+       *
+       * \return Always return true since we are on the Host in this case.
+       */
+      bool operator==(Host const&, Host const&)
+      {
+        return true;
+      }
+
+      /*
+       * \brief Compares two (Host) resources to see if they are NOT equal.
+       * (This was made in to a free function to appease MSVC and SYCL compilers)
+       *
+       * \return Always return false. Host resources are always the same.
+       */
+      bool operator!=(Host const&, Host const&)
+      {
+        return false;
+      }
   }  // namespace v1
 }  // namespace resources
 }  // namespace camp

include/camp/resource/omp_target.hpp

@@ -192,6 +192,25 @@ namespace resources
         }
         return ret;
       }
+      /*
+       * \brief Compares two (Omp) resources to see if they are equal.
+       *
+       * \return True or false depending on if this is the same dev int and addr ptr.
+       */
+      bool operator==(Omp const& o) const
+      {
+        return (dev == o.dev && addr == o.addr);
+      }
+
+      /*
+       * \brief Compares two (Omp) resources to see if they are NOT equal.
+       *
+       * \return Negation of == operator
+       */
+      bool operator!=(Omp const& o) const
+      {
+        return !(*this == o);
+      }
 
     private:
       char *addr;

include/camp/resource/sycl.hpp

@@ -198,6 +198,27 @@ namespace resources
       }
 
       sycl::queue *get_queue() { return qu; }
+      sycl::queue const *get_queue() const { return qu; }
+
+      /*
+       * \brief Compares two (Sycl) resources to see if they are equal.
+       *
+       * \return True or false depending on if this is the same queue.
+       */
+      bool operator==(Sycl const& s) const
+      {
+        return (get_queue() == s.get_queue());
+      }
+
+      /*
+       * \brief Compares two (Sycl) resources to see if they are NOT equal.
+       *
+       * \return Negation of == operator
+       */
+      bool operator!=(Sycl const& s) const
+      {
+        return !(*this == s);
+      }
 
     private:
       sycl::queue *qu;

test/resource.cpp

@@ -51,6 +51,53 @@ TEST(CampResource, GetPlatform)
   ASSERT_EQ(static_cast<const Resource>(Omp()).get_platform(), Platform::omp_target);
 #endif
 }
+TEST(CampResource, Compare)
+{
+  Resource h1{Host()};
+  Resource h2{Host()};
+  Host h; Resource h3{h};
+
+#ifdef CAMP_HAVE_CUDA
+  Resource r1{Cuda()};
+  Resource r2{Cuda()};
+  Cuda s; Resource r3{s};
+#endif
+#ifdef CAMP_HAVE_HIP
+  Resource r1{Hip()};
+  Resource r2{Hip()};
+  Hip s; Resource r3{s};
+#endif
+#ifdef CAMP_HAVE_OMP_OFFLOAD
+  Resource r1{Omp()};
+  Resource r2{Omp()};
+  Omp s; Resource r3{s};
+#endif
+
+  ASSERT_TRUE(h1 == h1);
+  ASSERT_TRUE(h1 == h2);
+
+  ASSERT_FALSE(h1 != h2);
+
+#if defined(CAMP_HAVE_CUDA) || \
+    defined(CAMP_HAVE_HIP) || \
+    defined(CAMP_HAVE_OMP_OFFLOAD)
+  ASSERT_TRUE(r1 == r1);
+  ASSERT_TRUE(r2 == r2);
+  ASSERT_TRUE(s == s);
+  ASSERT_TRUE(h == h);
+  ASSERT_TRUE(r1 != r2);
+  ASSERT_TRUE(r2 != r1);
+  ASSERT_TRUE(r1 != h1);
+  ASSERT_TRUE(r3 != h3);
+
+  ASSERT_FALSE(r1 == r2);
+  ASSERT_FALSE(r2 == r1);
+  ASSERT_FALSE(r2 == r3);
+  ASSERT_FALSE(h2 == r2);
+  ASSERT_FALSE(h3 == r3);
+  ASSERT_FALSE(r1 != r1);
+#endif
+}
 TEST(CampResource, ConvertWorks)
 {
   Resource h1{Host()};
@@ -72,6 +119,7 @@ TEST(CampResource, Reassignment)
   ASSERT_EQ(typeid(c2), typeid(h2));
 }
 
+
 TEST(CampResource, StreamSelect)
 {
   cudaStream_t stream1, stream2;