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

src/gpu_ib/context_ib_host.hpp

@@ -99,42 +99,42 @@ class GPUIBHostContext : public 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__ 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__ 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_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:
   /* Pointer to the backend's host interface */

src/gpu_ib/context_ib_tmpl_host.hpp

@@ -115,57 +115,57 @@ __host__ void GPUIBHostContext::to_all(roc_shmem_team_t team, T *dest,
 }
 
 template <typename T>
-__host__ void GPUIBHostContext::wait_until(T *ptr, roc_shmem_cmps cmp, T val) {
-  host_interface->wait_until<T>(ptr, cmp, val, context_window_info);
+__host__ void GPUIBHostContext::wait_until(T *ivars, roc_shmem_cmps cmp, T val) {
+  host_interface->wait_until<T>(ivars, cmp, val, context_window_info);
 }
 
 template <typename T>
-__host__ void GPUIBHostContext::wait_until_all(T *ptr, size_t nelems,
+__host__ void GPUIBHostContext::wait_until_all(T *ivars, size_t nelems,
                                                const int* status,
                                                roc_shmem_cmps cmp, T val) {
-  host_interface->wait_until_all<T>(ptr, nelems, status, cmp, val, context_window_info);
+  host_interface->wait_until_all<T>(ivars, nelems, status, cmp, val, context_window_info);
 }
 
 template <typename T>
-__host__ size_t GPUIBHostContext::wait_until_any(T *ptr, size_t nelems,
+__host__ size_t GPUIBHostContext::wait_until_any(T *ivars, size_t nelems,
                                                const int* status,
                                                roc_shmem_cmps cmp, T val) {
-  return host_interface->wait_until_any<T>(ptr, nelems, status, cmp, val, context_window_info);
+  return host_interface->wait_until_any<T>(ivars, nelems, status, cmp, val, context_window_info);
 }
 
 template <typename T>
-__host__ size_t GPUIBHostContext::wait_until_some(T *ptr, size_t nelems,
+__host__ size_t GPUIBHostContext::wait_until_some(T *ivars, size_t nelems,
                                                  size_t* indices,
                                                  const int* status,
                                                  roc_shmem_cmps cmp, T val) {
-  return host_interface->wait_until_some<T>(ptr, nelems, indices, status, cmp, val, context_window_info);
+  return host_interface->wait_until_some<T>(ivars, nelems, indices, status, cmp, val, context_window_info);
 }
 
 template <typename T>
-__host__ void GPUIBHostContext::wait_until_all_vector(T *ptr, size_t nelems,
+__host__ void GPUIBHostContext::wait_until_all_vector(T *ivars, size_t nelems,
                                                       const int* status,
                                                       roc_shmem_cmps cmp, T* vals) {
-  host_interface->wait_until_all_vector<T>(ptr, nelems, status, cmp, vals, context_window_info);
+  host_interface->wait_until_all_vector<T>(ivars, nelems, status, cmp, vals, context_window_info);
 }
 
 template <typename T>
-__host__ size_t GPUIBHostContext::wait_until_any_vector(T *ptr, size_t nelems,
+__host__ size_t GPUIBHostContext::wait_until_any_vector(T *ivars, size_t nelems,
                                                         const int* status,
                                                         roc_shmem_cmps cmp, T* vals) {
-  return host_interface->wait_until_any_vector<T>(ptr, nelems, status, cmp, vals, context_window_info);
+  return host_interface->wait_until_any_vector<T>(ivars, nelems, status, cmp, vals, context_window_info);
 }
 
 template <typename T>
-__host__ size_t GPUIBHostContext::wait_until_some_vector(T *ptr, size_t nelems,
+__host__ size_t GPUIBHostContext::wait_until_some_vector(T *ivars, size_t nelems,
                                                          size_t* indices,
                                                          const int* status,
                                                          roc_shmem_cmps cmp, T* vals) {
-  return host_interface->wait_until_some_vector<T>(ptr, nelems, indices, status, cmp, vals, context_window_info);
+  return host_interface->wait_until_some_vector<T>(ivars, nelems, indices, status, cmp, vals, context_window_info);
 }
 
 template <typename T>
-__host__ int GPUIBHostContext::test(T *ptr, roc_shmem_cmps cmp, T val) {
-  return host_interface->test<T>(ptr, cmp, val, context_window_info);
+__host__ int GPUIBHostContext::test(T *ivars, roc_shmem_cmps cmp, T val) {
+  return host_interface->test<T>(ivars, cmp, val, context_window_info);
 }
 
 }  // namespace rocshmem