*_wait* routines changed parameter from ptr to ivars to match OpenSHMEM

src/context.hpp

@@ -74,42 +74,42 @@ class Context {
    ***************************** DEVICE METHODS *****************************
    *************************************************************************/
   template <typename T>
-  __device__ void wait_until(T* ptr, roc_shmem_cmps cmp, T val);
+  __device__ void wait_until(T *ivars, roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __device__ void wait_until_all(T* ptr, size_t nelems,
+  __device__ void wait_until_all(T *ivars, size_t nelems,
                                  const int *status,
                                  roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __device__ size_t wait_until_any(T* ptr, size_t nelems,
+  __device__ size_t wait_until_any(T *ivars, size_t nelems,
                                    const int *status,
                                    roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __device__ size_t wait_until_some(T* ptr, size_t nelems,
+  __device__ size_t wait_until_some(T *ivars, size_t nelems,
                                     size_t* indices,
                                     const int *status,
                                     roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __device__ void wait_until_all_vector(T* ptr, size_t nelems,
+  __device__ void wait_until_all_vector(T *ivars, size_t nelems,
                                         const int *status,
                                         roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __device__ size_t wait_until_any_vector(T* ptr, size_t nelems,
+  __device__ size_t wait_until_any_vector(T *ivars, size_t nelems,
                                           const int *status,
                                           roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __device__ size_t wait_until_some_vector(T* ptr, size_t nelems,
+  __device__ size_t wait_until_some_vector(T *ivars, size_t nelems,
                                            size_t* indices,
                                            const int *status,
                                            roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __device__ int test(T* ptr, roc_shmem_cmps cmp, T val);
+  __device__ int test(T *ivars, roc_shmem_cmps cmp, T val);
 
   __device__ void threadfence_system();
 
@@ -365,42 +365,42 @@ class Context {
                        int nreduce);
 
   template <typename T>
-  __host__ void wait_until(T* ptr, roc_shmem_cmps cmp, T val);
+  __host__ void wait_until(T *ivars, roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __host__ void wait_until_all(T* ptr, size_t nelems,
+  __host__ void wait_until_all(T *ivars, size_t nelems,
                                const int *status,
                                roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __host__ size_t wait_until_any(T* ptr, size_t nelems,
+  __host__ size_t wait_until_any(T *ivars, size_t nelems,
                                  const int *status,
                                  roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __host__ size_t wait_until_some(T* ptr, size_t nelems,
+  __host__ size_t wait_until_some(T *ivars, size_t nelems,
                                   size_t* indices,
                                   const int *status,
                                   roc_shmem_cmps cmp, T val);
 
   template <typename T>
-  __host__ void wait_until_all_vector(T* ptr, size_t nelems,
+  __host__ void wait_until_all_vector(T *ivars, size_t nelems,
                                       const int *status,
                                       roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __host__ size_t wait_until_any_vector(T* ptr, size_t nelems,
+  __host__ size_t wait_until_any_vector(T *ivars, size_t nelems,
                                         const int *status,
                                         roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __host__ size_t wait_until_some_vector(T* ptr, size_t nelems,
+  __host__ size_t wait_until_some_vector(T *ivars, size_t nelems,
                                          size_t* indices,
                                          const int *status,
                                          roc_shmem_cmps cmp, T* vals);
 
   template <typename T>
-  __host__ int test(T* ptr, roc_shmem_cmps cmp, T val);
+  __host__ int test(T *ivars, roc_shmem_cmps cmp, T val);
 
  public:
   /**